version3/swift/BenchtestALL.swift - incubator-milagro-crypto - Git at Google

 /*
 	Licensed to the Apache Software Foundation (ASF) under one
 	or more contributor license agreements.  See the NOTICE file
 	distributed with this work for additional information
 	regarding copyright ownership.  The ASF licenses this file
 	to you under the Apache License, Version 2.0 (the
 	"License"); you may not use this file except in compliance
 	with the License.  You may obtain a copy of the License at

 	http://www.apache.org/licenses/LICENSE-2.0

 	Unless required by applicable law or agreed to in writing,
 	software distributed under the License is distributed on an
 	"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 	KIND, either express or implied.  See the License for the
 	specific language governing permissions and limitations
 	under the License.
 */

 //
 //  TestECDH.swift
 //
 //  Created by Michael Scott on 02/07/2015.
 //  Copyright (c) 2015 Michael Scott. All rights reserved.
 //

 import Foundation
 import amcl // comment out for Xcode
 import ed25519
 import nist256
 import goldilocks
 import bn254
 import bls383
 import bls24
 import bls48
 import rsa2048

 public func TimeRSA_2048(_ rng: inout RAND)
 {
     let RFS=RSA.RFS
     let MIN_TIME=10.0
     let MIN_ITERS=10
     var fail=false;

     var pub=rsa_public_key(Int(FF.FFLEN))
     var priv=rsa_private_key(Int(FF.HFLEN))

     var M=[UInt8](repeating: 0,count: RFS)
     var C=[UInt8](repeating: 0,count: RFS)
     var P=[UInt8](repeating: 0,count: RFS)

     print("\nTiming/Testing 2048-bit RSA")
     print("Generating public/private key pair")

     var start=Date()
     var iterations=0
     var elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         RSA.KEY_PAIR(&rng,65537,&priv,&pub)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "RSA gen - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     for i in 0..<RFS {M[i]=UInt8(i%128)}

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         RSA.ENCRYPT(pub,M,&C)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "RSA enc - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         RSA.DECRYPT(priv,C,&P)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "RSA dec - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     var cmp=true
     for i in 0..<RFS {
         if P[i] != M[i] {cmp=false}
     }

     if !cmp {
         print("FAILURE - RSA decryption")
         fail=true;
     }

     if !fail {
        print("All tests pass")
     }
 }


 public func TimeECDH_ed25519(_ rng: inout RAND)
 {
     let MIN_TIME=10.0
     let MIN_ITERS=10

     var fail=false;

     print("\nTiming/Testing ED25519 ECC")
     if ed25519.ECP.CURVETYPE==ed25519.ECP.WEIERSTRASS {
         print("Weierstrass parameterisation")
     }
     if ed25519.ECP.CURVETYPE==ed25519.ECP.EDWARDS {
         print("Edwards parameterisation")
     }
     if ed25519.ECP.CURVETYPE==ed25519.ECP.MONTGOMERY {
         print("Montgomery representation")
     }
     if ed25519.FP.MODTYPE==ed25519.FP.PSEUDO_MERSENNE {
         print("Pseudo-Mersenne Modulus")
     }
     if ed25519.FP.MODTYPE==ed25519.FP.MONTGOMERY_FRIENDLY {
         print("Montgomery Friendly Modulus")
     }
     if ed25519.FP.MODTYPE==ed25519.FP.GENERALISED_MERSENNE {
         print("Generalised-Mersenne Modulus")
     }
     if ed25519.FP.MODTYPE==ed25519.FP.NOT_SPECIAL {
         print("Not special Modulus")
     }
     print("Modulus size \(ed25519.FP.MODBITS) bits")
     print("\(ed25519.BIG.CHUNK) bit build")


     var s:ed25519.BIG
     let G=ed25519.ECP.generator();

     let r=ed25519.BIG(ed25519.ROM.CURVE_Order)
     s=ed25519.BIG.randomnum(r,&rng)

     var W=G.mul(r)
     if !W.is_infinity() {
         print("FAILURE - rG!=O")
         fail=true;
     }

     let start=Date()
     var iterations=0
     var elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         W=G.mul(s)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "EC  mul - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     if !fail {
        print("All tests pass")
     }
 }

 public func TimeECDH_nist256(_ rng: inout RAND)
 {
     let MIN_TIME=10.0
     let MIN_ITERS=10

     var fail=false;

     print("\nTiming/Testing NIST256 ECC")
     if nist256.ECP.CURVETYPE==nist256.ECP.WEIERSTRASS {
         print("Weierstrass parameterisation")
     }
     if nist256.ECP.CURVETYPE==nist256.ECP.EDWARDS {
         print("Edwards parameterisation")
     }
     if nist256.ECP.CURVETYPE==nist256.ECP.MONTGOMERY {
         print("Montgomery representation")
     }
     if nist256.FP.MODTYPE==nist256.FP.PSEUDO_MERSENNE {
         print("Pseudo-Mersenne Modulus")
     }
     if nist256.FP.MODTYPE==nist256.FP.MONTGOMERY_FRIENDLY {
         print("Montgomery Friendly Modulus")
     }
     if nist256.FP.MODTYPE==nist256.FP.GENERALISED_MERSENNE {
         print("Generalised-Mersenne Modulus")
     }
     if nist256.FP.MODTYPE==nist256.FP.NOT_SPECIAL {
         print("Not special Modulus")
     }
     print("Modulus size \(nist256.FP.MODBITS) bits")
     print("\(nist256.BIG.CHUNK) bit build")


     var s:nist256.BIG
     let G=nist256.ECP.generator();

     let r=nist256.BIG(nist256.ROM.CURVE_Order)
     s=nist256.BIG.randomnum(r,&rng)

     var W=G.mul(r)
     if !W.is_infinity() {
         print("FAILURE - rG!=O")
         fail=true;
     }

     let start=Date()
     var iterations=0
     var elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         W=G.mul(s)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "EC  mul - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     if !fail {
        print("All tests pass")
     }
 }


 public func TimeECDH_goldilocks(_ rng: inout RAND)
 {
     let MIN_TIME=10.0
     let MIN_ITERS=10

     var fail=false;

     print("\nTiming/Testing GOLDILOCKS ECC")
     if goldilocks.ECP.CURVETYPE==goldilocks.ECP.WEIERSTRASS {
         print("Weierstrass parameterisation")
     }
     if goldilocks.ECP.CURVETYPE==goldilocks.ECP.EDWARDS {
         print("Edwards parameterisation")
     }
     if goldilocks.ECP.CURVETYPE==goldilocks.ECP.MONTGOMERY {
         print("Montgomery representation")
     }
     if goldilocks.FP.MODTYPE==goldilocks.FP.PSEUDO_MERSENNE {
         print("Pseudo-Mersenne Modulus")
     }
     if goldilocks.FP.MODTYPE==goldilocks.FP.MONTGOMERY_FRIENDLY {
         print("Montgomery Friendly Modulus")
     }
     if goldilocks.FP.MODTYPE==goldilocks.FP.GENERALISED_MERSENNE {
         print("Generalised-Mersenne Modulus")
     }
     if goldilocks.FP.MODTYPE==goldilocks.FP.NOT_SPECIAL {
         print("Not special Modulus")
     }
     print("Modulus size \(goldilocks.FP.MODBITS) bits")
     print("\(goldilocks.BIG.CHUNK) bit build")


     var s:goldilocks.BIG
     let G=goldilocks.ECP.generator();

     let r=goldilocks.BIG(goldilocks.ROM.CURVE_Order)
     s=goldilocks.BIG.randomnum(r,&rng)

     var W=G.mul(r)
     if !W.is_infinity() {
         print("FAILURE - rG!=O")
         fail=true;
     }

     let start=Date()
     var iterations=0
     var elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         W=G.mul(s)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "EC  mul - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     if !fail {
        print("All tests pass")
     }
 }

 public func TimeMPIN_bn254(_ rng: inout RAND)
 {
     let MIN_TIME=10.0
     let MIN_ITERS=10
     var fail=false;

     print("\nTiming/Testing BN254 Pairings")
     if bn254.ECP.CURVE_PAIRING_TYPE==bn254.ECP.BN {
         print("BN Pairing-Friendly Curve")
     }
     if bn254.ECP.CURVE_PAIRING_TYPE==bn254.ECP.BLS {
         print("BLS Pairing-Friendly Curve")
     }
     print("Modulus size \(bn254.FP.MODBITS) bits")
     print("\(bn254.BIG.CHUNK) bit build")

     let G=bn254.ECP.generator();

     let r=bn254.BIG(bn254.ROM.CURVE_Order)
     let s=bn254.BIG.randomnum(r,&rng)

     var P=bn254.PAIR.G1mul(G,r);

     if !P.is_infinity() {
         print("FAILURE - rP!=O")
         fail=true
     }

     var start=Date()
     var iterations=0
     var elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         P=bn254.PAIR.G1mul(G,s)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "G1  mul              - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     var Q=bn254.ECP2.generator();

     var W=bn254.PAIR.G2mul(Q,r)

     if !W.is_infinity() {
         print("FAILURE - rQ!=O")
         fail=true
     }

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         W=bn254.PAIR.G2mul(Q,s)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "G2  mul              - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     var w=bn254.PAIR.ate(Q,P)
     w=bn254.PAIR.fexp(w)

     var g=bn254.PAIR.GTpow(w,r)

     if !g.isunity() {
         print("FAILURE - g^r!=1")
         fail=true
     }

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         g=bn254.PAIR.GTpow(w,s)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "GT  pow              - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     g.copy(w)

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         _=g.compow(s,r)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "GT  pow (compressed) - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         w=bn254.PAIR.ate(Q,P)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "PAIRing ATE          - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         g=bn254.PAIR.fexp(w)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "PAIRing FEXP         - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     P.copy(G)
     Q.copy(W)

     P=bn254.PAIR.G1mul(P,s)
     g=bn254.PAIR.ate(Q,P)
     g=bn254.PAIR.fexp(g)

     P.copy(G)
     Q=bn254.PAIR.G2mul(Q,s)
     w=bn254.PAIR.ate(Q,P)
     w=bn254.PAIR.fexp(w)

     if !g.equals(w) {
         print("FAILURE - e(sQ,P)!=e(Q,sP)")
         fail=true
     }

     if !fail {
         print("All tests pass")
     }
 }

 public func TimeMPIN_bls383(_ rng: inout RAND)
 {
     let MIN_TIME=10.0
     let MIN_ITERS=10
     var fail=false;

     print("\nTiming/Testing BLS383 Pairings")
     if bls383.ECP.CURVE_PAIRING_TYPE==bls383.ECP.BN {
         print("BN Pairing-Friendly Curve")
     }
     if bls383.ECP.CURVE_PAIRING_TYPE==bls383.ECP.BLS {
         print("BLS Pairing-Friendly Curve")
     }
     print("Modulus size \(bls383.FP.MODBITS) bits")
     print("\(bls383.BIG.CHUNK) bit build")

     let G=bls383.ECP.generator();

     let r=bls383.BIG(bls383.ROM.CURVE_Order)
     let s=bls383.BIG.randomnum(r,&rng)

     var P=bls383.PAIR.G1mul(G,r);

     if !P.is_infinity() {
         print("FAILURE - rP!=O")
         fail=true
     }

     var start=Date()
     var iterations=0
     var elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         P=bls383.PAIR.G1mul(G,s)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "G1  mul              - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     var Q=bls383.ECP2.generator();

     var W=bls383.PAIR.G2mul(Q,r)

     if !W.is_infinity() {
         print("FAILURE - rQ!=O")
         fail=true
     }

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         W=bls383.PAIR.G2mul(Q,s)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "G2  mul              - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     var w=bls383.PAIR.ate(Q,P)
     w=bls383.PAIR.fexp(w)

     var g=bls383.PAIR.GTpow(w,r)

     if !g.isunity() {
         print("FAILURE - g^r!=1")
         fail=true
     }

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         g=bls383.PAIR.GTpow(w,s)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "GT  pow              - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     g.copy(w)

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         _=g.compow(s,r)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "GT  pow (compressed) - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         w=bls383.PAIR.ate(Q,P)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "PAIRing ATE          - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         g=bls383.PAIR.fexp(w)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "PAIRing FEXP         - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     P.copy(G)
     Q.copy(W)

     P=bls383.PAIR.G1mul(P,s)
     g=bls383.PAIR.ate(Q,P)
     g=bls383.PAIR.fexp(g)

     P.copy(G)
     Q=bls383.PAIR.G2mul(Q,s)
     w=bls383.PAIR.ate(Q,P)
     w=bls383.PAIR.fexp(w)

     if !g.equals(w) {
         print("FAILURE - e(sQ,P)!=e(Q,sP)")
         fail=true
     }

     if !fail {
         print("All tests pass")
     }
 }


 public func TimeMPIN_bls24(_ rng: inout RAND)
 {
     let MIN_TIME=10.0
     let MIN_ITERS=10
     var fail=false;

     print("\nTiming/Testing BLS24 Pairings")
     if bls24.ECP.CURVE_PAIRING_TYPE==bls24.ECP.BN {
         print("BN Pairing-Friendly Curve")
     }
     if bls24.ECP.CURVE_PAIRING_TYPE==bls24.ECP.BLS {
         print("BLS24 Pairing-Friendly Curve")
     }
     print("Modulus size \(bls24.FP.MODBITS) bits")
     print("\(bls24.BIG.CHUNK) bit build")

     let G=bls24.ECP.generator();

     let r=bls24.BIG(bls24.ROM.CURVE_Order)
     let s=bls24.BIG.randomnum(r,&rng)

     var P=PAIR192.G1mul(G,r);

     if !P.is_infinity() {
         print("FAILURE - rP!=O")
         fail=true
     }

     var start=Date()
     var iterations=0
     var elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         P=PAIR192.G1mul(G,s)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "G1  mul              - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     var Q=ECP4.generator();

     var W=PAIR192.G2mul(Q,r)

     if !W.is_infinity() {
         print("FAILURE - rQ!=O")
         fail=true
     }

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         W=PAIR192.G2mul(Q,s)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "G2  mul              - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     var w=PAIR192.ate(Q,P)
     w=PAIR192.fexp(w)

     var g=PAIR192.GTpow(w,r)

     if !g.isunity() {
         print("FAILURE - g^r!=1")
         fail=true
     }

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         g=PAIR192.GTpow(w,s)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "GT  pow              - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     g.copy(w)

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         _=g.compow(s,r)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "GT  pow (compressed) - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         w=PAIR192.ate(Q,P)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "PAIRing ATE          - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         g=PAIR192.fexp(w)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "PAIRing FEXP         - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     P.copy(G)
     Q.copy(W)

     P=PAIR192.G1mul(P,s)
     g=PAIR192.ate(Q,P)
     g=PAIR192.fexp(g)

     P.copy(G)
     Q=PAIR192.G2mul(Q,s)
     w=PAIR192.ate(Q,P)
     w=PAIR192.fexp(w)

     if !g.equals(w) {
         print("FAILURE - e(sQ,P)!=e(Q,sP)")
         fail=true
     }

     if !fail {
         print("All tests pass")
     }
 }


 public func TimeMPIN_bls48(_ rng: inout RAND)
 {
     let MIN_TIME=10.0
     let MIN_ITERS=10
     var fail=false;

     print("\nTiming/Testing BLS48 Pairings")
     if bls48.ECP.CURVE_PAIRING_TYPE==bls48.ECP.BN {
         print("BN Pairing-Friendly Curve")
     }
     if bls48.ECP.CURVE_PAIRING_TYPE==bls48.ECP.BLS {
         print("BLS48 Pairing-Friendly Curve")
     }
     print("Modulus size \(bls48.FP.MODBITS) bits")
     print("\(bls48.BIG.CHUNK) bit build")

     let G=bls48.ECP.generator();

     let r=bls48.BIG(bls48.ROM.CURVE_Order)
     let s=bls48.BIG.randomnum(r,&rng)

     var P=PAIR256.G1mul(G,r);

     if !P.is_infinity() {
         print("FAILURE - rP!=O")
         fail=true
     }

     var start=Date()
     var iterations=0
     var elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         P=PAIR256.G1mul(G,s)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "G1  mul              - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     var Q=ECP8.generator();

     var W=PAIR256.G2mul(Q,r)

     if !W.is_infinity() {
         print("FAILURE - rQ!=O")
         fail=true
     }

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         W=PAIR256.G2mul(Q,s)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "G2  mul              - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     var w=PAIR256.ate(Q,P)
     w=PAIR256.fexp(w)

     var g=PAIR256.GTpow(w,r)

     if !g.isunity() {
         print("FAILURE - g^r!=1")
         fail=true
     }

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         g=PAIR256.GTpow(w,s)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "GT  pow              - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     g.copy(w)

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         _=g.compow(s,r)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "GT  pow (compressed) - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         w=PAIR256.ate(Q,P)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "PAIRing ATE          - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     start=Date()
     iterations=0
     elapsed=0.0
     while elapsed<MIN_TIME || iterations<MIN_ITERS {
         g=PAIR256.fexp(w)
         iterations+=1
         elapsed = -start.timeIntervalSinceNow
     }
     elapsed=1000.0*elapsed/Double(iterations)
     print(String(format: "PAIRing FEXP         - %d iterations",iterations),terminator: "");
     print(String(format: " %.2f ms per iteration",elapsed))

     P.copy(G)
     Q.copy(W)

     P=PAIR256.G1mul(P,s)
     g=PAIR256.ate(Q,P)
     g=PAIR256.fexp(g)

     P.copy(G)
     Q=PAIR256.G2mul(Q,s)
     w=PAIR256.ate(Q,P)
     w=PAIR256.fexp(w)

     if !g.equals(w) {
         print("FAILURE - e(sQ,P)!=e(Q,sP)")
         fail=true
     }

     if !fail {
         print("All tests pass")
     }
 }


 var RAW=[UInt8](repeating: 0,count: 100)
 var rng=RAND()

 rng.clean();
 for i in 0 ..< 100 {RAW[i]=UInt8(i&0xff)}
 rng.seed(100,RAW)


 TimeECDH_ed25519(&rng)
 TimeECDH_nist256(&rng)
 TimeECDH_goldilocks(&rng)
 TimeRSA_2048(&rng)
 TimeMPIN_bn254(&rng)
 TimeMPIN_bls383(&rng)
 TimeMPIN_bls24(&rng)
 TimeMPIN_bls48(&rng)
	/*
	Licensed to the Apache Software Foundation (ASF) under one
	or more contributor license agreements. See the NOTICE file
	distributed with this work for additional information
	regarding copyright ownership. The ASF licenses this file
	to you under the Apache License, Version 2.0 (the
	"License"); you may not use this file except in compliance
	with the License. You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

	Unless required by applicable law or agreed to in writing,
	software distributed under the License is distributed on an
	"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	KIND, either express or implied. See the License for the
	specific language governing permissions and limitations
	under the License.
	*/

	//
	// TestECDH.swift
	//
	// Created by Michael Scott on 02/07/2015.
	// Copyright (c) 2015 Michael Scott. All rights reserved.
	//

	import Foundation
	import amcl // comment out for Xcode
	import ed25519
	import nist256
	import goldilocks
	import bn254
	import bls383
	import bls24
	import bls48
	import rsa2048

	public func TimeRSA_2048(_ rng: inout RAND)
	{
	let RFS=RSA.RFS
	let MIN_TIME=10.0
	let MIN_ITERS=10
	var fail=false;

	var pub=rsa_public_key(Int(FF.FFLEN))
	var priv=rsa_private_key(Int(FF.HFLEN))

	var M=[UInt8](repeating: 0,count: RFS)
	var C=[UInt8](repeating: 0,count: RFS)
	var P=[UInt8](repeating: 0,count: RFS)

	print("\nTiming/Testing 2048-bit RSA")
	print("Generating public/private key pair")

	var start=Date()
	var iterations=0
	var elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	RSA.KEY_PAIR(&rng,65537,&priv,&pub)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "RSA gen - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	for i in 0..<RFS {M[i]=UInt8(i%128)}

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	RSA.ENCRYPT(pub,M,&C)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "RSA enc - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	RSA.DECRYPT(priv,C,&P)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "RSA dec - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	var cmp=true
	for i in 0..<RFS {
	if P[i] != M[i] {cmp=false}
	}

	if !cmp {
	print("FAILURE - RSA decryption")
	fail=true;
	}

	if !fail {
	print("All tests pass")
	}
	}


	public func TimeECDH_ed25519(_ rng: inout RAND)
	{
	let MIN_TIME=10.0
	let MIN_ITERS=10

	var fail=false;

	print("\nTiming/Testing ED25519 ECC")
	if ed25519.ECP.CURVETYPE==ed25519.ECP.WEIERSTRASS {
	print("Weierstrass parameterisation")
	}
	if ed25519.ECP.CURVETYPE==ed25519.ECP.EDWARDS {
	print("Edwards parameterisation")
	}
	if ed25519.ECP.CURVETYPE==ed25519.ECP.MONTGOMERY {
	print("Montgomery representation")
	}
	if ed25519.FP.MODTYPE==ed25519.FP.PSEUDO_MERSENNE {
	print("Pseudo-Mersenne Modulus")
	}
	if ed25519.FP.MODTYPE==ed25519.FP.MONTGOMERY_FRIENDLY {
	print("Montgomery Friendly Modulus")
	}
	if ed25519.FP.MODTYPE==ed25519.FP.GENERALISED_MERSENNE {
	print("Generalised-Mersenne Modulus")
	}
	if ed25519.FP.MODTYPE==ed25519.FP.NOT_SPECIAL {
	print("Not special Modulus")
	}
	print("Modulus size \(ed25519.FP.MODBITS) bits")
	print("\(ed25519.BIG.CHUNK) bit build")


	var s:ed25519.BIG
	let G=ed25519.ECP.generator();

	let r=ed25519.BIG(ed25519.ROM.CURVE_Order)
	s=ed25519.BIG.randomnum(r,&rng)

	var W=G.mul(r)
	if !W.is_infinity() {
	print("FAILURE - rG!=O")
	fail=true;
	}

	let start=Date()
	var iterations=0
	var elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	W=G.mul(s)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "EC mul - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	if !fail {
	print("All tests pass")
	}
	}

	public func TimeECDH_nist256(_ rng: inout RAND)
	{
	let MIN_TIME=10.0
	let MIN_ITERS=10

	var fail=false;

	print("\nTiming/Testing NIST256 ECC")
	if nist256.ECP.CURVETYPE==nist256.ECP.WEIERSTRASS {
	print("Weierstrass parameterisation")
	}
	if nist256.ECP.CURVETYPE==nist256.ECP.EDWARDS {
	print("Edwards parameterisation")
	}
	if nist256.ECP.CURVETYPE==nist256.ECP.MONTGOMERY {
	print("Montgomery representation")
	}
	if nist256.FP.MODTYPE==nist256.FP.PSEUDO_MERSENNE {
	print("Pseudo-Mersenne Modulus")
	}
	if nist256.FP.MODTYPE==nist256.FP.MONTGOMERY_FRIENDLY {
	print("Montgomery Friendly Modulus")
	}
	if nist256.FP.MODTYPE==nist256.FP.GENERALISED_MERSENNE {
	print("Generalised-Mersenne Modulus")
	}
	if nist256.FP.MODTYPE==nist256.FP.NOT_SPECIAL {
	print("Not special Modulus")
	}
	print("Modulus size \(nist256.FP.MODBITS) bits")
	print("\(nist256.BIG.CHUNK) bit build")


	var s:nist256.BIG
	let G=nist256.ECP.generator();

	let r=nist256.BIG(nist256.ROM.CURVE_Order)
	s=nist256.BIG.randomnum(r,&rng)

	var W=G.mul(r)
	if !W.is_infinity() {
	print("FAILURE - rG!=O")
	fail=true;
	}

	let start=Date()
	var iterations=0
	var elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	W=G.mul(s)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "EC mul - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	if !fail {
	print("All tests pass")
	}
	}


	public func TimeECDH_goldilocks(_ rng: inout RAND)
	{
	let MIN_TIME=10.0
	let MIN_ITERS=10

	var fail=false;

	print("\nTiming/Testing GOLDILOCKS ECC")
	if goldilocks.ECP.CURVETYPE==goldilocks.ECP.WEIERSTRASS {
	print("Weierstrass parameterisation")
	}
	if goldilocks.ECP.CURVETYPE==goldilocks.ECP.EDWARDS {
	print("Edwards parameterisation")
	}
	if goldilocks.ECP.CURVETYPE==goldilocks.ECP.MONTGOMERY {
	print("Montgomery representation")
	}
	if goldilocks.FP.MODTYPE==goldilocks.FP.PSEUDO_MERSENNE {
	print("Pseudo-Mersenne Modulus")
	}
	if goldilocks.FP.MODTYPE==goldilocks.FP.MONTGOMERY_FRIENDLY {
	print("Montgomery Friendly Modulus")
	}
	if goldilocks.FP.MODTYPE==goldilocks.FP.GENERALISED_MERSENNE {
	print("Generalised-Mersenne Modulus")
	}
	if goldilocks.FP.MODTYPE==goldilocks.FP.NOT_SPECIAL {
	print("Not special Modulus")
	}
	print("Modulus size \(goldilocks.FP.MODBITS) bits")
	print("\(goldilocks.BIG.CHUNK) bit build")


	var s:goldilocks.BIG
	let G=goldilocks.ECP.generator();

	let r=goldilocks.BIG(goldilocks.ROM.CURVE_Order)
	s=goldilocks.BIG.randomnum(r,&rng)

	var W=G.mul(r)
	if !W.is_infinity() {
	print("FAILURE - rG!=O")
	fail=true;
	}

	let start=Date()
	var iterations=0
	var elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	W=G.mul(s)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "EC mul - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	if !fail {
	print("All tests pass")
	}
	}

	public func TimeMPIN_bn254(_ rng: inout RAND)
	{
	let MIN_TIME=10.0
	let MIN_ITERS=10
	var fail=false;

	print("\nTiming/Testing BN254 Pairings")
	if bn254.ECP.CURVE_PAIRING_TYPE==bn254.ECP.BN {
	print("BN Pairing-Friendly Curve")
	}
	if bn254.ECP.CURVE_PAIRING_TYPE==bn254.ECP.BLS {
	print("BLS Pairing-Friendly Curve")
	}
	print("Modulus size \(bn254.FP.MODBITS) bits")
	print("\(bn254.BIG.CHUNK) bit build")

	let G=bn254.ECP.generator();

	let r=bn254.BIG(bn254.ROM.CURVE_Order)
	let s=bn254.BIG.randomnum(r,&rng)

	var P=bn254.PAIR.G1mul(G,r);

	if !P.is_infinity() {
	print("FAILURE - rP!=O")
	fail=true
	}

	var start=Date()
	var iterations=0
	var elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	P=bn254.PAIR.G1mul(G,s)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "G1 mul - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	var Q=bn254.ECP2.generator();

	var W=bn254.PAIR.G2mul(Q,r)

	if !W.is_infinity() {
	print("FAILURE - rQ!=O")
	fail=true
	}

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	W=bn254.PAIR.G2mul(Q,s)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "G2 mul - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	var w=bn254.PAIR.ate(Q,P)
	w=bn254.PAIR.fexp(w)

	var g=bn254.PAIR.GTpow(w,r)

	if !g.isunity() {
	print("FAILURE - g^r!=1")
	fail=true
	}

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	g=bn254.PAIR.GTpow(w,s)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "GT pow - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	g.copy(w)

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	_=g.compow(s,r)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "GT pow (compressed) - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	w=bn254.PAIR.ate(Q,P)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "PAIRing ATE - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	g=bn254.PAIR.fexp(w)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "PAIRing FEXP - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	P.copy(G)
	Q.copy(W)

	P=bn254.PAIR.G1mul(P,s)
	g=bn254.PAIR.ate(Q,P)
	g=bn254.PAIR.fexp(g)

	P.copy(G)
	Q=bn254.PAIR.G2mul(Q,s)
	w=bn254.PAIR.ate(Q,P)
	w=bn254.PAIR.fexp(w)

	if !g.equals(w) {
	print("FAILURE - e(sQ,P)!=e(Q,sP)")
	fail=true
	}

	if !fail {
	print("All tests pass")
	}
	}

	public func TimeMPIN_bls383(_ rng: inout RAND)
	{
	let MIN_TIME=10.0
	let MIN_ITERS=10
	var fail=false;

	print("\nTiming/Testing BLS383 Pairings")
	if bls383.ECP.CURVE_PAIRING_TYPE==bls383.ECP.BN {
	print("BN Pairing-Friendly Curve")
	}
	if bls383.ECP.CURVE_PAIRING_TYPE==bls383.ECP.BLS {
	print("BLS Pairing-Friendly Curve")
	}
	print("Modulus size \(bls383.FP.MODBITS) bits")
	print("\(bls383.BIG.CHUNK) bit build")

	let G=bls383.ECP.generator();

	let r=bls383.BIG(bls383.ROM.CURVE_Order)
	let s=bls383.BIG.randomnum(r,&rng)

	var P=bls383.PAIR.G1mul(G,r);

	if !P.is_infinity() {
	print("FAILURE - rP!=O")
	fail=true
	}

	var start=Date()
	var iterations=0
	var elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	P=bls383.PAIR.G1mul(G,s)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "G1 mul - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	var Q=bls383.ECP2.generator();

	var W=bls383.PAIR.G2mul(Q,r)

	if !W.is_infinity() {
	print("FAILURE - rQ!=O")
	fail=true
	}

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	W=bls383.PAIR.G2mul(Q,s)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "G2 mul - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	var w=bls383.PAIR.ate(Q,P)
	w=bls383.PAIR.fexp(w)

	var g=bls383.PAIR.GTpow(w,r)

	if !g.isunity() {
	print("FAILURE - g^r!=1")
	fail=true
	}

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	g=bls383.PAIR.GTpow(w,s)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "GT pow - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	g.copy(w)

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	_=g.compow(s,r)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "GT pow (compressed) - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	w=bls383.PAIR.ate(Q,P)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "PAIRing ATE - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	g=bls383.PAIR.fexp(w)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "PAIRing FEXP - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	P.copy(G)
	Q.copy(W)

	P=bls383.PAIR.G1mul(P,s)
	g=bls383.PAIR.ate(Q,P)
	g=bls383.PAIR.fexp(g)

	P.copy(G)
	Q=bls383.PAIR.G2mul(Q,s)
	w=bls383.PAIR.ate(Q,P)
	w=bls383.PAIR.fexp(w)

	if !g.equals(w) {
	print("FAILURE - e(sQ,P)!=e(Q,sP)")
	fail=true
	}

	if !fail {
	print("All tests pass")
	}
	}


	public func TimeMPIN_bls24(_ rng: inout RAND)
	{
	let MIN_TIME=10.0
	let MIN_ITERS=10
	var fail=false;

	print("\nTiming/Testing BLS24 Pairings")
	if bls24.ECP.CURVE_PAIRING_TYPE==bls24.ECP.BN {
	print("BN Pairing-Friendly Curve")
	}
	if bls24.ECP.CURVE_PAIRING_TYPE==bls24.ECP.BLS {
	print("BLS24 Pairing-Friendly Curve")
	}
	print("Modulus size \(bls24.FP.MODBITS) bits")
	print("\(bls24.BIG.CHUNK) bit build")

	let G=bls24.ECP.generator();

	let r=bls24.BIG(bls24.ROM.CURVE_Order)
	let s=bls24.BIG.randomnum(r,&rng)

	var P=PAIR192.G1mul(G,r);

	if !P.is_infinity() {
	print("FAILURE - rP!=O")
	fail=true
	}

	var start=Date()
	var iterations=0
	var elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	P=PAIR192.G1mul(G,s)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "G1 mul - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	var Q=ECP4.generator();

	var W=PAIR192.G2mul(Q,r)

	if !W.is_infinity() {
	print("FAILURE - rQ!=O")
	fail=true
	}

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	W=PAIR192.G2mul(Q,s)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "G2 mul - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	var w=PAIR192.ate(Q,P)
	w=PAIR192.fexp(w)

	var g=PAIR192.GTpow(w,r)

	if !g.isunity() {
	print("FAILURE - g^r!=1")
	fail=true
	}

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	g=PAIR192.GTpow(w,s)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "GT pow - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	g.copy(w)

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	_=g.compow(s,r)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "GT pow (compressed) - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	w=PAIR192.ate(Q,P)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "PAIRing ATE - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	g=PAIR192.fexp(w)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "PAIRing FEXP - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	P.copy(G)
	Q.copy(W)

	P=PAIR192.G1mul(P,s)
	g=PAIR192.ate(Q,P)
	g=PAIR192.fexp(g)

	P.copy(G)
	Q=PAIR192.G2mul(Q,s)
	w=PAIR192.ate(Q,P)
	w=PAIR192.fexp(w)

	if !g.equals(w) {
	print("FAILURE - e(sQ,P)!=e(Q,sP)")
	fail=true
	}

	if !fail {
	print("All tests pass")
	}
	}


	public func TimeMPIN_bls48(_ rng: inout RAND)
	{
	let MIN_TIME=10.0
	let MIN_ITERS=10
	var fail=false;

	print("\nTiming/Testing BLS48 Pairings")
	if bls48.ECP.CURVE_PAIRING_TYPE==bls48.ECP.BN {
	print("BN Pairing-Friendly Curve")
	}
	if bls48.ECP.CURVE_PAIRING_TYPE==bls48.ECP.BLS {
	print("BLS48 Pairing-Friendly Curve")
	}
	print("Modulus size \(bls48.FP.MODBITS) bits")
	print("\(bls48.BIG.CHUNK) bit build")

	let G=bls48.ECP.generator();

	let r=bls48.BIG(bls48.ROM.CURVE_Order)
	let s=bls48.BIG.randomnum(r,&rng)

	var P=PAIR256.G1mul(G,r);

	if !P.is_infinity() {
	print("FAILURE - rP!=O")
	fail=true
	}

	var start=Date()
	var iterations=0
	var elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	P=PAIR256.G1mul(G,s)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "G1 mul - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	var Q=ECP8.generator();

	var W=PAIR256.G2mul(Q,r)

	if !W.is_infinity() {
	print("FAILURE - rQ!=O")
	fail=true
	}

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	W=PAIR256.G2mul(Q,s)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "G2 mul - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	var w=PAIR256.ate(Q,P)
	w=PAIR256.fexp(w)

	var g=PAIR256.GTpow(w,r)

	if !g.isunity() {
	print("FAILURE - g^r!=1")
	fail=true
	}

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	g=PAIR256.GTpow(w,s)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "GT pow - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	g.copy(w)

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	_=g.compow(s,r)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "GT pow (compressed) - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	w=PAIR256.ate(Q,P)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "PAIRing ATE - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	start=Date()
	iterations=0
	elapsed=0.0
	while elapsed<MIN_TIME \|\| iterations<MIN_ITERS {
	g=PAIR256.fexp(w)
	iterations+=1
	elapsed = -start.timeIntervalSinceNow
	}
	elapsed=1000.0*elapsed/Double(iterations)
	print(String(format: "PAIRing FEXP - %d iterations",iterations),terminator: "");
	print(String(format: " %.2f ms per iteration",elapsed))

	P.copy(G)
	Q.copy(W)

	P=PAIR256.G1mul(P,s)
	g=PAIR256.ate(Q,P)
	g=PAIR256.fexp(g)

	P.copy(G)
	Q=PAIR256.G2mul(Q,s)
	w=PAIR256.ate(Q,P)
	w=PAIR256.fexp(w)

	if !g.equals(w) {
	print("FAILURE - e(sQ,P)!=e(Q,sP)")
	fail=true
	}

	if !fail {
	print("All tests pass")
	}
	}


	var RAW=[UInt8](repeating: 0,count: 100)
	var rng=RAND()

	rng.clean();
	for i in 0 ..< 100 {RAW[i]=UInt8(i&0xff)}
	rng.seed(100,RAW)


	TimeECDH_ed25519(&rng)
	TimeECDH_nist256(&rng)
	TimeECDH_goldilocks(&rng)
	TimeRSA_2048(&rng)
	TimeMPIN_bn254(&rng)
	TimeMPIN_bls383(&rng)
	TimeMPIN_bls24(&rng)
	TimeMPIN_bls48(&rng)