import org.apache.commons.codec.digest.DigestUtils
import org.apache.commons.codec.digest.MessageDigestAlgorithms.SHA_1
import java.math.BigDecimal
import java.math.BigInteger
import java.util.*


const val L = 512
const val N = 64
val q = BigInteger.probablePrime(N, Random())
val p :BigInteger = {
    var p :BigInteger
    print("Calculating p...")
    do {
        p = BigInteger.probablePrime(L, Random())
        print('.')
    }while((p.minus(BigInteger.ONE)).mod(q) == BigInteger.ZERO)
    println("Done!")
    p
    }()

val g :BigInteger = {
    var g :BigInteger
    var h :BigInteger = BigInteger.ONE
    print("Calculating q...")
    do {
        h += BigInteger.ONE
         g = h.modPow((p - BigInteger.ONE)/q,p)
        print('.')
    }while(g.modPow(q,p) == BigInteger.ONE)
    println("Done")
    g
}()


fun main(args: Array<String>) {
    val x = {
        var randomNumber: BigInteger
        val random = Random()
        do {
            randomNumber = BigInteger(q.bitLength(),random )
        } while (randomNumber >= q)
        randomNumber
    }()
    val y = g.modPow(x,p)
    println("$x:$y")
    val string = "string"
    val pair = string.sign(x)
    println("${pair.r}:${pair.s}")
    if(string.verify(y,pair.r,pair.s)){
        println("it worked")
    }else{
        System.err.println("fuck")
    }

}

fun String.sign(x :BigInteger):RSPair{
    var r :BigInteger
    var k :BigInteger
    do{
        k =  random(BigInteger.valueOf(10))
        r = g.modPow(k,p).mod(q)
    }while(r == BigInteger.ZERO)
    var s :BigDecimal
    while(true) {
        s = (BigDecimal.valueOf(1)/k.toBigDecimal()).times((this.sha1() + x * r).toBigDecimal()).rem(q.toBigDecimal())
        if(s == BigDecimal.ZERO){
            do{
                k =  random(BigInteger.valueOf(10))
                r = g.modPow(k,p).mod(q)
            }while(r == BigInteger.ZERO)//regenerate k and r
        }else{
            break
        }
    }
    return RSPair(r,s.toBigIntegerExact())
}

data class RSPair(val r :BigInteger, val s :BigInteger)

fun random(top :BigInteger):BigInteger{
    val rand = Random()
    var result :BigInteger
    do {
        result = BigInteger(top.bitLength(), rand)
    }while(result >= top || result <= BigInteger.ZERO)
    return result
}

fun String.verify(y :BigInteger, r :BigInteger, s: BigInteger):Boolean{
    if(BigInteger.ZERO < r || r < q)return false
    if(BigInteger.ZERO < s || s < q)return false
    val w = s.pow(-1).mod(q)
    val u1 = (this.sha1() * w).mod(q)
    val u2 = (r * w).mod(q)
    val v = (g.pow(u1.toInt()) * y.pow(u2.toInt())).mod(p).mod(q)
    return v == r
}


fun String.sha1():BigInteger {
    return BigInteger(1,DigestUtils(SHA_1).digest(this))
}