marklister · September 20, 2020 23:40 · gregwk · Mar 27, 2013 · marklister · Apr 9, 2013
diff --git a/Readme.md b/Readme.md
diff --git a/BaseN.scala b/BaseN.scala
 /**
 * Scala hex / decimal binary calculator
 * (c) Mark Lister 2012
 * Licence Apache 2.
 */

 class BaseN(b: BigInt, val baseN: Int) extends BigInt(b.underlying) {
  def n(x: Int) = new BaseN(b, x)

  /**
   * Return this BaseN as an array of Int normalized  in the range 0 -255
   */
  def toIntArray: Array[Int] = toByteArray.map(_ + 256).map(_ % 256)

  private def toB(n: BigInt): List[Int] = {
    if (n == 0) Nil else
      (n % 2).toInt :: toB(n / 2)
  }
  
  /**
   * Return the bit representation of this BaseN
   */
  def toBits = toB(this).reverse

  /**
   * Return this BaseN as a Byte Array with the sign byte removed (if it exists)
   */
  implicit override def toByteArray = if (super.toByteArray.head == 0) super.toByteArray.tail else super.toByteArray

  override def ^(that: BigInt): BaseN = BaseN(super.^(that), baseN)
  def xor(that: BigInt) = ^(that) //Synonym for ^
  override def +(that: BigInt) = BaseN(super.+(that), baseN)
  override def -(that: BigInt) = BaseN(super.-(that), baseN)
  override def *(that: BigInt) = BaseN(super.*(that), baseN)
  override def /(that: BigInt) = BaseN(super./(that), baseN)
  override def &(that: BigInt) = BaseN(super.&(that), baseN)
  override def |(that: BigInt) = BaseN(super.|(that), baseN)
  override def <<(n: Int) = BaseN(super.<<(n), baseN)
  override def >>(n: Int) = BaseN(super.>>(n), baseN)

  /**
   * Return the byte wise String representation of this BaseN.  For a non byte wise 
   * orientated version use toString(16) or toRawString
   */
  override def toString = {
    val len = (scala.Math.log(256) / scala.Math.log(baseN) + 0.999).toInt
    def toS(i: Int) = ("0" * len + BigInt(i).toString(baseN)).takeRight(len)
    toIntArray.map(toS(_)).mkString(":") + " [base: " + baseN + "]"
  }

  /**
   * Return the conventional String representation of this BaseN
   */
  def toRawString = super.toString(baseN)


 }

 object BaseN {
  def apply(b: BigInt, n: Int) = new BaseN(new BigInt(b.underlying), n)
  def apply(ba:Array[Byte])= new BaseN(BigInt(ba),16)

 //  implicit def toByteArray(n: BaseN): Array[Byte] = n.toByteArray  //hopefully the same method in the class does this.

  implicit def StringToBinary(s: String): Binary = new Binary(BigInt(s, 2))
  implicit def StringToHex(s: String): Hex = new Hex(BigInt(s, 16))
  implicit def StringToDecimal(s: String): Decimal = new Decimal(BigInt(s, 10))

  implicit def BaseNToHex(x: BaseN): Hex = new Hex(x)
  implicit def BaseNToHDecimal(x: BaseN): Decimal = new Decimal(x)
  implicit def BaseNToBinary(x: BaseN): BaseN = new Binary(x)

  implicit def IntToHex(i: Int): Hex = new Hex(BigInt(i)) // to support 0xff etc
  implicit def BaseNToInt(n: BaseN): Int = n.toInt

  implicit def BigIntToBinary(b: BigInt): Binary = new Binary(b)
  implicit def BigIntToHex(b: BigInt): Hex = new Hex(b)
  implicit def BigIntToDecimal(b: BigInt): Decimal = new Decimal(b)
  implicit def ArrayByteToHex(ba: Array[Byte]): Hex = new Hex(BigInt(ba))
  //implicit def SeqByteToHex(sb:Seq[Byte]):Hex=new Hex(BigInt(sb.toArray))
  implicit def BaseNToSeqByte(bn:BaseN):Seq[Byte]=bn.toByteArray.toSeq

 }

 class Hex(b: BigInt) extends BaseN(b, 16) {
  def h = this
 }

 class Decimal(b: BigInt) extends BaseN(b, 10) {
  def d = this
 }

 class Binary(b: BigInt) extends BaseN(b, 2) {
  def b = this
 }

 /**
 * CryptoOps is a sort of "RichByteArray" for Crypto primitives
 */
 import java.security.MessageDigest
 import javax.crypto.Cipher
 import javax.crypto.spec.SecretKeySpec
 class CryptoOps(val b:Array[Byte]){
    /**
   * Return the sha256 of this CryptOps
   */
  def sha256 = digest("SHA-256")
  
  /**
   * Return the SHA-1 of this BaseN
   */
  def sha1 = digest("SHA-1")
  
  /**
   * Return the MD5 of this BaseN
   */
  def md5 = digest("MD5")

  /**
   * Return a Digest of this CryptoOps that is supported by the underlying
   * security provider of the JVM (SHA1, SHA256 and MD5 are standard)
   * Private but you can change that if you need direct access. 
   */
  private def digest(d: String):Array[Byte] = {
    val md = MessageDigest.getInstance(d)
    md.update(b)
    md.digest
  }
  
  /**
   * Pad this CryptoOps to a multiple of 16 bytes by:  adding n bytes of value n
   * where n is the number of bytes required to make this a multiple of 16.
   * Where the block is a multiple of 16, a full block is added.
   */
  def pkcs5Pad: CryptoOps = pkcs5Pad(16)
  
  /**
   * Pad this block in the same way as pkcs5Pad but with a selectable block size.
   */
  def pkcs5Pad(n: Int): CryptoOps = {
    val p = n - b.length % n
    b ++ (1 to p).map(i => p.toByte)
  }
  
  /**
   * Return this CryptoOps encrypted using AES in ECB mode
   * Returns an Array[Byte]
   */
  def aesEncrypt(k: Array[Byte]):Array[Byte] = {
    val c = Cipher.getInstance("AES/ECB/NoPadding")
    val key = new SecretKeySpec(k, "AES")
    c.init(Cipher.ENCRYPT_MODE, key)
    c.doFinal(b)
  }
  
 /**
 * Return this CryptoOps decrypted using AES in ECB Mode
 * Returns an Array[Byte]
 */
  def aesDecrypt(k: Array[Byte]) = {
    val c = Cipher.getInstance("AES/ECB/NoPadding")
    val key = new SecretKeySpec(k, "AES")
    c.init(Cipher.DECRYPT_MODE, key)
    c.doFinal(b)
  }
 }

 object CryptoOps{
  def apply(b:Array[Byte])= new CryptoOps(b)
  implicit def ArrayByteToCryptoOps(ba:Array[Byte]):CryptoOps= CryptoOps(ba)
  implicit def SeqByteToCryptoOps(sb:Seq[Byte]):CryptoOps= CryptoOps(sb.toArray)
  implicit def CryptoOpsToByteArray(co:CryptoOps):Array[Byte]= co.b
  implicit def CryptoOpsToSeqByte(co:CryptoOps):Seq[Byte]= co.b.toSeq
  implicit def BaseNToCryptoOps(bn:BaseN)=CryptoOps(bn.toByteArray)
  implicit def CryptoOpsToBaseN(co:CryptoOps)=BaseN(co.b)
  implicit def CryptoOpsToHex(co:CryptoOps)=new Hex(BigInt(co.b))
 }
	/**
	* Scala hex / decimal binary calculator
	* (c) Mark Lister 2012
	* Licence Apache 2.
	*/

	class BaseN(b: BigInt, val baseN: Int) extends BigInt(b.underlying) {
	def n(x: Int) = new BaseN(b, x)

	/**
	* Return this BaseN as an array of Int normalized in the range 0 -255
	*/
	def toIntArray: Array[Int] = toByteArray.map(_ + 256).map(_ % 256)

	private def toB(n: BigInt): List[Int] = {
	if (n == 0) Nil else
	(n % 2).toInt :: toB(n / 2)
	}

	/**
	* Return the bit representation of this BaseN
	*/
	def toBits = toB(this).reverse

	/**
	* Return this BaseN as a Byte Array with the sign byte removed (if it exists)
	*/
	implicit override def toByteArray = if (super.toByteArray.head == 0) super.toByteArray.tail else super.toByteArray

	override def ^(that: BigInt): BaseN = BaseN(super.^(that), baseN)
	def xor(that: BigInt) = ^(that) //Synonym for ^
	override def +(that: BigInt) = BaseN(super.+(that), baseN)
	override def -(that: BigInt) = BaseN(super.-(that), baseN)
	override def (that: BigInt) = BaseN(super.(that), baseN)
	override def /(that: BigInt) = BaseN(super./(that), baseN)
	override def &(that: BigInt) = BaseN(super.&(that), baseN)
	override def \|(that: BigInt) = BaseN(super.\|(that), baseN)
	override def <<(n: Int) = BaseN(super.<<(n), baseN)
	override def >>(n: Int) = BaseN(super.>>(n), baseN)

	/**
	* Return the byte wise String representation of this BaseN. For a non byte wise
	* orientated version use toString(16) or toRawString
	*/
	override def toString = {
	val len = (scala.Math.log(256) / scala.Math.log(baseN) + 0.999).toInt
	def toS(i: Int) = ("0" * len + BigInt(i).toString(baseN)).takeRight(len)
	toIntArray.map(toS(_)).mkString(":") + " [base: " + baseN + "]"
	}

	/**
	* Return the conventional String representation of this BaseN
	*/
	def toRawString = super.toString(baseN)


	}

	object BaseN {
	def apply(b: BigInt, n: Int) = new BaseN(new BigInt(b.underlying), n)
	def apply(ba:Array[Byte])= new BaseN(BigInt(ba),16)

	// implicit def toByteArray(n: BaseN): Array[Byte] = n.toByteArray //hopefully the same method in the class does this.

	implicit def StringToBinary(s: String): Binary = new Binary(BigInt(s, 2))
	implicit def StringToHex(s: String): Hex = new Hex(BigInt(s, 16))
	implicit def StringToDecimal(s: String): Decimal = new Decimal(BigInt(s, 10))

	implicit def BaseNToHex(x: BaseN): Hex = new Hex(x)
	implicit def BaseNToHDecimal(x: BaseN): Decimal = new Decimal(x)
	implicit def BaseNToBinary(x: BaseN): BaseN = new Binary(x)

	implicit def IntToHex(i: Int): Hex = new Hex(BigInt(i)) // to support 0xff etc
	implicit def BaseNToInt(n: BaseN): Int = n.toInt

	implicit def BigIntToBinary(b: BigInt): Binary = new Binary(b)
	implicit def BigIntToHex(b: BigInt): Hex = new Hex(b)
	implicit def BigIntToDecimal(b: BigInt): Decimal = new Decimal(b)
	implicit def ArrayByteToHex(ba: Array[Byte]): Hex = new Hex(BigInt(ba))
	//implicit def SeqByteToHex(sb:Seq[Byte]):Hex=new Hex(BigInt(sb.toArray))
	implicit def BaseNToSeqByte(bn:BaseN):Seq[Byte]=bn.toByteArray.toSeq

	}

	class Hex(b: BigInt) extends BaseN(b, 16) {
	def h = this
	}

	class Decimal(b: BigInt) extends BaseN(b, 10) {
	def d = this
	}

	class Binary(b: BigInt) extends BaseN(b, 2) {
	def b = this
	}

	/**
	* CryptoOps is a sort of "RichByteArray" for Crypto primitives
	*/
	import java.security.MessageDigest
	import javax.crypto.Cipher
	import javax.crypto.spec.SecretKeySpec
	class CryptoOps(val b:Array[Byte]){
	/**
	* Return the sha256 of this CryptOps
	*/
	def sha256 = digest("SHA-256")

	/**
	* Return the SHA-1 of this BaseN
	*/
	def sha1 = digest("SHA-1")

	/**
	* Return the MD5 of this BaseN
	*/
	def md5 = digest("MD5")

	/**
	* Return a Digest of this CryptoOps that is supported by the underlying
	* security provider of the JVM (SHA1, SHA256 and MD5 are standard)
	* Private but you can change that if you need direct access.
	*/
	private def digest(d: String):Array[Byte] = {
	val md = MessageDigest.getInstance(d)
	md.update(b)
	md.digest
	}

	/**
	* Pad this CryptoOps to a multiple of 16 bytes by: adding n bytes of value n
	* where n is the number of bytes required to make this a multiple of 16.
	* Where the block is a multiple of 16, a full block is added.
	*/
	def pkcs5Pad: CryptoOps = pkcs5Pad(16)

	/**
	* Pad this block in the same way as pkcs5Pad but with a selectable block size.
	*/
	def pkcs5Pad(n: Int): CryptoOps = {
	val p = n - b.length % n
	b ++ (1 to p).map(i => p.toByte)
	}

	/**
	* Return this CryptoOps encrypted using AES in ECB mode
	* Returns an Array[Byte]
	*/
	def aesEncrypt(k: Array[Byte]):Array[Byte] = {
	val c = Cipher.getInstance("AES/ECB/NoPadding")
	val key = new SecretKeySpec(k, "AES")
	c.init(Cipher.ENCRYPT_MODE, key)
	c.doFinal(b)
	}

	/**
	* Return this CryptoOps decrypted using AES in ECB Mode
	* Returns an Array[Byte]
	*/
	def aesDecrypt(k: Array[Byte]) = {
	val c = Cipher.getInstance("AES/ECB/NoPadding")
	val key = new SecretKeySpec(k, "AES")
	c.init(Cipher.DECRYPT_MODE, key)
	c.doFinal(b)
	}
	}

	object CryptoOps{
	def apply(b:Array[Byte])= new CryptoOps(b)
	implicit def ArrayByteToCryptoOps(ba:Array[Byte]):CryptoOps= CryptoOps(ba)
	implicit def SeqByteToCryptoOps(sb:Seq[Byte]):CryptoOps= CryptoOps(sb.toArray)
	implicit def CryptoOpsToByteArray(co:CryptoOps):Array[Byte]= co.b
	implicit def CryptoOpsToSeqByte(co:CryptoOps):Seq[Byte]= co.b.toSeq
	implicit def BaseNToCryptoOps(bn:BaseN)=CryptoOps(bn.toByteArray)
	implicit def CryptoOpsToBaseN(co:CryptoOps)=BaseN(co.b)
	implicit def CryptoOpsToHex(co:CryptoOps)=new Hex(BigInt(co.b))
	}