public void BitStringSupport2()
{
String bitMask = "110110110110110110110110101101101";
BitString b = new BitString(bitMask);
Assert.AreEqual (bitMask, b.ToString ());
}
/// <summary>
/// Constructs a new index generator
/// </summary>
///
/// <param name="Seed">A seed of arbitrary length to initialize the index generator</param>
/// <param name="EncParam">NtruEncrypt parameters</param>
public IndexGenerator(byte[] Seed, NTRUParameters EncParam)
{
_N = EncParam.N;
_C = EncParam.CBits;
int minCallsR = EncParam.MinIGFHashCalls;
_digestEngine = GetDigest(EncParam.Digest);
_hashLen = _digestEngine.DigestSize;
_Z = Seed;
_callCounter = 0;
_bitBuffer = new BitString();
while (_callCounter < minCallsR)
{
byte[] data = new byte[_Z.Length + 4];
Buffer.BlockCopy(_Z, 0, data, 0, _Z.Length);
Buffer.BlockCopy(IntUtils.IntToBytes(_callCounter), 0, data, _Z.Length, 4);
byte[] H = _digestEngine.ComputeHash(data);
_bitBuffer.AppendBits(H);
_callCounter++;
}
_remLen = minCallsR * 8 * _hashLen;
}
public void TestByteHexLEConsistency()
{
Assert.AreEqual(BitString.FromHexLE("616263").Bits(), BitString.FromBytesLE(new byte[] { 0x61, 0x62, 0x63 }).Bits(), "LE hex-bytes conversion is incosistent");
}
public void TestHexLEKnownVectors()
{
Assert.AreEqual(new bool[] { false, true, false, true, false, false, false, true }, BitString.FromHexLE("8A").Bits(), "BS From hex string failed");
Assert.AreEqual(new bool[] { false, true, false, true, false, false, false, true, false, false, false, false, true, true, true, true }, BitString.FromHexLE("8AF0").Bits(), "BS From hex string failed");
Assert.AreEqual(new bool[] { false, false, false, false, true, true, true, true }, BitString.FromHexLE("F0").Bits(), "BS From hex string failed");
Assert.AreEqual("E5", new BitString(new bool[] { true, false, true, false, false, true, true, true }).ToHexLE(), "BS to Hex string failed");
Assert.AreEqual("D4", new BitString(new bool[] { false, false, true, false, true, false, true, true }).ToHexLE(), "BS to Hex string failed");
Assert.AreEqual("E5D4", new BitString(new bool[] { true, false, true, false, false, true, true, true, false, false, true, false, true, false, true, true }).ToHexLE(), "BS to Hex sstring failed");
}
public AllUsagesCollector2(Links links, BitString usages)
{
_links = links;
_usages = usages;
}
/**
* Created a JPEG image from the specified BitmapData
*
* @param image The BitmapData that will be converted into the JPEG format.
* @return a ByteArray representing the JPEG encoded image data.
* @langversion ActionScript 3.0
* @playerversion Flash 9.0
* @tiptext
*/
private void encode()
{
// Initialize bit writer
byteout = new ByteArray();
bytenew = 0;
bytepos = 7;
// Add JPEG headers
writeWord(0xFFD8); // SOI
writeAPP0();
writeDQT();
writeSOF0(image.width, image.height);
writeDHT();
writeSOS();
// Encode 8x8 macroblocks
float DCY =0.0f;
float DCU =0.0f;
float DCV =0.0f;
bytenew = 0;
bytepos = 7;
for ( int ypos=0; ypos < image.height; ypos += 8 )
{
for ( int xpos =0; xpos < image.width; xpos += 8 )
{
RGB2YUV(image, xpos, ypos);
DCY = processDU(YDU, fdtbl_Y, DCY, YDC_HT, YAC_HT);
DCU = processDU(UDU, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
DCV = processDU(VDU, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
// let other threads do stuff too
//Thread.Sleep(0);
}
}
// Do the bit alignment of the EOI marker
if ( bytepos >= 0 )
{
BitString fillbits = new BitString();
fillbits.len = bytepos + 1;
fillbits.val = (1 << (bytepos + 1)) - 1;
writeBits(fillbits);
}
writeWord(0xFFD9); //EOI
//return byteout;
isDone = true;
}
public void BitStringSupport()
{
const string bitMask = "1101101101101101101101101011011011010110110110";
var b = new BitString(bitMask);
Assert.AreEqual(bitMask, b.ToString());
}
/// <summary>
/// Returns the last <c>NumBits</c> bits from the end of the bit string
/// </summary>
///
/// <param name="NumBits">Number of bits to return</param>
///
/// <returns>A new <c>BitString</c> of length <c>numBits</c></returns>
public BitString GetTrailing(int NumBits)
{
BitString newStr = new BitString();
newStr._numBytes = (NumBits + 7) / 8;
newStr.Bytes = new byte[newStr._numBytes];
for (int i = 0; i < newStr._numBytes; i++)
newStr.Bytes[i] = Bytes[i];
newStr._lastByteBits = NumBits % 8;
if (newStr._lastByteBits == 0)
{
newStr._lastByteBits = 8;
}
else
{
int s = 32 - newStr._lastByteBits;
newStr.Bytes[newStr._numBytes - 1] = (byte)(IntUtils.URShift((newStr.Bytes[newStr._numBytes - 1] << s), s));
}
return newStr;
}
/// <summary>
/// Convert a postgresql bit to a System.Boolean if length is 1, else a BitString.
/// </summary>
internal static Object ToBitBinary(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int32 fieldValueSize,
Int32 TypeModifier)
{
BitString bs = new BitString(BackendData);
return TypeInfo.NpgsqlDbType == NpgsqlDbType.Bit && TypeModifier == 1 ? (object)bs[0] : bs;
}
private void Update(BitString newContent)
{
_message = BitString.ConcatenateBits(_message, newContent);
}
// These functions are for portability
private void Init()
{
_message = new BitString(0);
_cSHAKE = new CSHAKE.CSHAKE();
}
/// <summary>
/// Constructs an instance
/// </summary>
/// <param name="partyId">The party's ID.</param>
/// <param name="ephemeralData">The party's ephemeral data used for FixedInfo construction.</param>
public PartyFixedInfo(BitString partyId, BitString ephemeralData)
{
PartyId = partyId;
EphemeralData = ephemeralData;
}
public SubjectPublicKeyInfo(AlgorithmIdentifier algorithm, BitString subjectPublicKey) : base(algorithm, subjectPublicKey)
{
}
public void Bug1011321WrongBitStringvalue()
{
BitString b = new BitString (true, 32);
Assert.AreEqual ("11111111111111111111111111111111", b.ToString ());
}
public List<ulong> GetAllConnections3(params ulong[] linksToConnect)
{
return _sync.ExecuteReadOperation(() =>
{
var results = new BitString((long)_links.Total + 1); // new BitArray((int)_links.Total + 1);
if (linksToConnect.Length > 0)
{
EnsureEachLinkExists(_links, linksToConnect);
var collector1 = new AllUsagesCollector2(_links, results);
collector1.Collect(linksToConnect[0]);
for (int i = 1; i < linksToConnect.Length; i++)
{
var next = new BitString((long)_links.Total + 1); //new BitArray((int)_links.Total + 1);
var collector = new AllUsagesCollector2(_links, next);
collector.Collect(linksToConnect[i]);
results = results.And(next);
}
}
return results.GetSetUInt64Indices();
});
}
protected override DrbgStatus InstantiateAlgorithm(BitString entropyInput, BitString nonce, BitString personalizationString)
{
// 1
var seedMaterial = entropyInput
.ConcatenateBits(nonce)
.ConcatenateBits(personalizationString);
// 2
var seed = Hash_Df(seedMaterial, HashAttributes.SeedLength).Bits;
// 3
V = seed.GetDeepCopy();
// 4
C = Hash_Df(BitString.Zeroes(8).ConcatenateBits(V), seed.BitLength).Bits.GetDeepCopy();
// 5
ReseedCounter = 1;
// 6
return(DrbgStatus.Success);
}
protected void checkBitString(BitString decoded, BitString standard)
{
ByteTools.checkBuffers(decoded.Value, standard.Value);
Assert.AreEqual(decoded.TrailBitsCnt, standard.TrailBitsCnt);
}
public BitString HashMessage(BitString message, int digestLength, int capacity, int blockSize, bool xof, BitString customizationHex)
{
Init();
Update(message);
return(Final(digestLength, capacity, blockSize, xof, customizationHex));
}
private void WriteBits( BitString bs )
{
int value = bs.value;
int posval = bs.length-1;
while ( posval >= 0 )
{
if ( (value & System.Convert.ToUInt32(1 << posval)) != 0 )
{
bytenew |= System.Convert.ToUInt32(1 << bytepos);
}
posval--;
bytepos--;
if (bytepos < 0)
{
if (bytenew == 0xFF)
{
WriteByte(0xFF);
WriteByte(0);
}
else
{
WriteByte((byte)bytenew);
}
bytepos=7;
bytenew=0;
}
}
}
private BitString Final(int digestLength, int capacity, int blockSize, bool xof, BitString customizationHex)
{
var newMessage = ParallelHashHelpers.FormatMessage(_message, _cSHAKE, digestLength, capacity, blockSize, xof);
return(_cSHAKE.HashMessage(new Common.Hash.CSHAKE.HashFunction(digestLength, capacity), newMessage, customizationHex, FunctionName).Digest);
}
/// <summary>
/// Returns a number
/// </summary>
///
/// <returns>The next pseudo-random index</returns>
public int NextIndex()
{
while (true)
{
if (_remLen < _C)
{
BitString M = _bitBuffer.GetTrailing(_remLen);
int tmpLen = _C - _remLen;
int cThreshold = _callCounter + (tmpLen + _hashLen - 1) / _hashLen;
while (_callCounter < cThreshold)
{
byte[] data = new byte[_Z.Length + 4];
Buffer.BlockCopy(_Z, 0, data, 0, _Z.Length);
Buffer.BlockCopy(IntUtils.IntToBytes(_callCounter), 0, data, _Z.Length, 4);
byte[] H = _digestEngine.ComputeHash(data);
M.AppendBits(H);
_callCounter++;
_remLen += 8 * _hashLen;
}
_bitBuffer = M;
}
// assume c less than 32
int i = _bitBuffer.Pop(_C);
_remLen -= _C;
if (i < (1 << _C) - ((1 << _C) % _N))
return i % _N;
}
}
public FakeOtherInfoFactory(BitString otherInfo)
{
_otherInfo = otherInfo;
}
public void Bug1011321WrongBitStringvalue3()
{
var b = new BitString(true, 32);
var b2 = new BitString("11111111111111111111111111111111");
Assert.IsTrue(b == b2);
}
public FakeOtherInfo(BitString otherInfo)
{
_otherInfo = otherInfo;
}
private float processDU(float[] CDU, float[] fdtbl, float DC, BitString[] HTDC, BitString[] HTAC)
{
BitString EOB = HTAC[0x00];
BitString M16zeroes = HTAC[0xF0];
int i;
float[] DU_DCT = fDCTQuant(CDU, fdtbl);
//ZigZag reorder
for ( i = 0; i < 64; i++ )
{
DU[ZigZag[i]] = (int)(DU_DCT[i]);
}
int Diff = (int)(DU[0] - DC);
DC = DU[0];
//Encode DC
if ( Diff == 0 )
{
writeBits(HTDC[0]); // Diff might be 0
}
else
{
writeBits(HTDC[category[32767 + Diff]]);
writeBits(bitcode[32767 + Diff]);
}
//Encode ACs
int end0pos = 63;
for ( ; (end0pos > 0) && (DU[end0pos] == 0); end0pos-- )
{
};
//end0pos = first element in reverse order !=0
if ( end0pos == 0 )
{
writeBits(EOB);
return DC;
}
i = 1;
while ( i <= end0pos )
{
int startpos = i;
for ( ; (DU[i] == 0) && (i <= end0pos); i++ )
{
}
int nrzeroes = i - startpos;
if ( nrzeroes >= 16 )
{
for ( int nrmarker =1; nrmarker <= nrzeroes / 16; nrmarker++ )
{
writeBits(M16zeroes);
}
nrzeroes = (nrzeroes & 0xF);
}
writeBits(HTAC[nrzeroes * 16 + category[32767 + DU[i]]]);
writeBits(bitcode[32767 + DU[i]]);
i++;
}
if ( end0pos != 63 )
{
writeBits(EOB);
}
return DC;
}
public KdfResult(BitString key)
{
DerivedKey = key;
}
public void TestXorInvalid() => Assert.Throws(typeof(InvalidOperationException), () => (BitString.oS(5) ^ BitString.S1).Bits(), "BS Xor worked on different length BSs - should not");
public void ShouldFindIVsEncrypt(string keyHex, string ptHex, string ctHex, string iv)
{
var key = new BitString(keyHex);
var pt = new BitString(ptHex);
var ct = new BitString(ctHex);
string[] ivsarray =
{
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF1",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF2",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF3",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF4",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF6",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF8",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF9",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFB",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
"00000000000000000000000000000000",
"00000000000000000000000000000001",
"00000000000000000000000000000002",
"00000000000000000000000000000003",
"00000000000000000000000000000004",
"00000000000000000000000000000005",
"00000000000000000000000000000006",
"00000000000000000000000000000007",
"00000000000000000000000000000008",
"00000000000000000000000000000009",
"0000000000000000000000000000000A",
"0000000000000000000000000000000B",
"0000000000000000000000000000000C",
"0000000000000000000000000000000D",
"0000000000000000000000000000000E",
"0000000000000000000000000000000F",
"00000000000000000000000000000010",
"00000000000000000000000000000011",
"00000000000000000000000000000012",
"00000000000000000000000000000013",
"00000000000000000000000000000014",
"00000000000000000000000000000015",
"00000000000000000000000000000016",
"00000000000000000000000000000017",
"00000000000000000000000000000018",
"00000000000000000000000000000019",
"0000000000000000000000000000001A",
"0000000000000000000000000000001B",
"0000000000000000000000000000001C",
"0000000000000000000000000000001D",
"0000000000000000000000000000001E",
"0000000000000000000000000000001F",
"00000000000000000000000000000020",
"00000000000000000000000000000021",
"00000000000000000000000000000022",
"00000000000000000000000000000023",
"00000000000000000000000000000024",
"00000000000000000000000000000025",
"00000000000000000000000000000026",
"00000000000000000000000000000027",
"00000000000000000000000000000028",
"00000000000000000000000000000029",
"0000000000000000000000000000002A",
"0000000000000000000000000000002B",
"0000000000000000000000000000002C",
"0000000000000000000000000000002D",
"0000000000000000000000000000002E",
"0000000000000000000000000000002F",
"00000000000000000000000000000030",
"00000000000000000000000000000031",
"00000000000000000000000000000032",
"00000000000000000000000000000033",
"00000000000000000000000000000034",
"00000000000000000000000000000035",
"00000000000000000000000000000036",
"00000000000000000000000000000037",
"00000000000000000000000000000038",
"00000000000000000000000000000039",
"0000000000000000000000000000003A",
"0000000000000000000000000000003B",
"0000000000000000000000000000003C",
"0000000000000000000000000000003D",
"0000000000000000000000000000003E",
"0000000000000000000000000000003F",
"00000000000000000000000000000040",
"00000000000000000000000000000041",
"00000000000000000000000000000042",
"00000000000000000000000000000043",
"00000000000000000000000000000044",
"00000000000000000000000000000045",
"00000000000000000000000000000046",
"00000000000000000000000000000047",
"00000000000000000000000000000048",
"00000000000000000000000000000049",
"0000000000000000000000000000004A",
"0000000000000000000000000000004B",
"0000000000000000000000000000004C",
"0000000000000000000000000000004D",
"0000000000000000000000000000004E",
"0000000000000000000000000000004F",
"00000000000000000000000000000050",
"00000000000000000000000000000051",
"00000000000000000000000000000052",
"00000000000000000000000000000053"
};
var ivsCorrect = new List <BitString>();
foreach (var ivgiven in ivsarray)
{
ivsCorrect.Add(new BitString(ivgiven));
}
_subject = new CtrBlockCipher(new AesEngine(), new TestableCounter(new AesEngine(), ivsCorrect));
var param = new CounterModeBlockCipherParameters(BlockCipherDirections.Encrypt, key, pt, ct);
var result = _subject.ExtractIvs(param);
Assert.AreEqual(ivsCorrect, result.IVs);
}
public void TestHexSelfConsistency()
{
bool[] b1 = nextFillBits(new bool[rng.Next(5) * 8]);
Assert.AreEqual(b1, (BitString.FromHexBE(new BitString(b1).ToHexBE())).Bits(), "Base 64 double conversion failed");
}
public void ShouldFindIVsDecrypt(string keyHex, string ctHex, string ptHex, string iv)
{
var key = new BitString(keyHex);
var pt = new BitString(ptHex);
var ct = new BitString(ctHex);
string[] ivsarray =
{
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC0",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC1",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC2",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC3",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC4",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC5",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC6",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC8",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC9",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFCA",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFCB",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFCC",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFCD",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFCE",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFCF",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD0",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD1",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD2",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD3",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD4",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD5",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD6",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD7",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD8",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD9",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDA",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDB",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDC",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDD",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDE",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDF",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE0",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE1",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE2",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE3",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE4",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE5",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE6",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE7",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE8",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE9",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEA",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEB",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEC",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEE",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEF",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF1",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF2",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF3",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF4",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF6",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF8",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF9",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFB",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
"00000000000000000000000000000000",
"00000000000000000000000000000001",
"00000000000000000000000000000002",
"00000000000000000000000000000003",
"00000000000000000000000000000004",
"00000000000000000000000000000005",
"00000000000000000000000000000006",
"00000000000000000000000000000007",
"00000000000000000000000000000008",
"00000000000000000000000000000009",
"0000000000000000000000000000000A",
"0000000000000000000000000000000B",
"0000000000000000000000000000000C",
"0000000000000000000000000000000D",
"0000000000000000000000000000000E",
"0000000000000000000000000000000F",
"00000000000000000000000000000010",
"00000000000000000000000000000011",
"00000000000000000000000000000012",
"00000000000000000000000000000013",
"00000000000000000000000000000014",
"00000000000000000000000000000015",
"00000000000000000000000000000016",
"00000000000000000000000000000017",
"00000000000000000000000000000018",
"00000000000000000000000000000019",
"0000000000000000000000000000001A",
"0000000000000000000000000000001B",
"0000000000000000000000000000001C",
"0000000000000000000000000000001D",
"0000000000000000000000000000001E",
"0000000000000000000000000000001F",
"00000000000000000000000000000020",
"00000000000000000000000000000021",
"00000000000000000000000000000022",
"00000000000000000000000000000023"
};
var ivsCorrect = new List <BitString>();
foreach (var ivgiven in ivsarray)
{
ivsCorrect.Add(new BitString(ivgiven));
}
_subject = new CtrBlockCipher(new AesEngine(), new TestableCounter(new AesEngine(), ivsCorrect));
var param = new CounterModeBlockCipherParameters(BlockCipherDirections.Encrypt, key, pt, ct);
var result = _subject.ExtractIvs(param);
Assert.AreEqual(ivsCorrect, result.IVs);
}
public ChangeOfBitString(BitString referencedBitstring, StatusFlags statusFlags)
{
ReferencedBitstring = referencedBitstring;
StatusFlags = statusFlags;
}
public ChangeOfValue(BitString newValue, StatusFlags statusFlags)
{
NewValue = new Choice(0, newValue);
StatusFlags = statusFlags;
}
public EdPoint Decode(BitString encoded)
{
return(EdPointEncoder.Decode(encoded, FieldSizeQ, CoefficientA, CoefficientD, VariableB));
}
public FfcDomainParametersValidateRequest(FfcDomainParameters pqgDomainParameters, DomainSeed seed, Counter count, BitString index, PrimeGenMode primeGen, GeneratorGenMode genGen)
{
PqgDomainParameters = pqgDomainParameters;
Seed = seed;
Count = count;
Index = index;
PrimeGen = primeGen;
GeneratorGen = genGen;
}
public HssVerificationResult VerifyHssSignature(BitString msg, BitString publicKey, BitString signature)
{
// 1. The signature S is parsed into its components as follows:
// a. Nspk = strTou32(first four bytes of S)
// if Nspk+1 is not equal to the number of levels L in pub return INVALID
var Nspk = (int)signature.MSBSubstring(0, 32).ToPositiveBigInteger();
var lengthInPublic = (int)publicKey.MSBSubstring(0, 32).ToPositiveBigInteger();
if (Nspk + 1 != lengthInPublic)
{
return(new HssVerificationResult("Validation failed. L values do not match."));
}
// b. for (i = 0; i<Nspk; i = i + 1) {
// siglist[i] = next LMS signature parsed from S
// publist[i] = next LMS public key parsed from S
// }
var siglist = new BitString[Nspk + 1];
var publist = new BitString[Nspk + 1];
var currIndex = 32;
for (int i = 0; i < Nspk; i++)
{
// assume sig and pub have same LMS mode
var otsCode = signature.MSBSubstring(currIndex + 32, 32);
var n = LmotsModeMapping.GetNFromCode(otsCode);
var p = LmotsModeMapping.GetPFromCode(otsCode);
var sigtype = signature.MSBSubstring((8 + n * (p + 1)) * 8 + currIndex, 32);
var m = LmsModeMapping.GetMFromCode(sigtype);
var h = LmsModeMapping.GetHFromCode(sigtype);
var siglen = (12 + n * (p + 1) + m * h) * 8;
var publen = 192 + (m * 8);
siglist[i] = signature.MSBSubstring(currIndex, siglen);
currIndex += siglen;
publist[i] = signature.MSBSubstring(currIndex, publen);
currIndex += publen;
}
// c. siglist[Nspk] = next LMS signature parsed from S
var otsCodeLast = signature.MSBSubstring(currIndex + 32, 32);
var nLast = LmotsModeMapping.GetNFromCode(otsCodeLast);
var pLast = LmotsModeMapping.GetPFromCode(otsCodeLast);
var sigtypeLast = signature.MSBSubstring((8 + nLast * (pLast + 1)) * 8 + currIndex, 32);
var mLast = LmsModeMapping.GetMFromCode(sigtypeLast);
var hLast = LmsModeMapping.GetHFromCode(sigtypeLast);
var siglenLast = (12 + nLast * (pLast + 1) + mLast * hLast) * 8;
siglist[Nspk] = signature.MSBSubstring(currIndex, siglenLast);
// 2. Verify each part of the signature
var key = publicKey.MSBSubstring(32, publicKey.BitLength - 32);
for (int i = 0; i < Nspk; i++)
{
var result = _lms[i].VerifyLmsSignature(publist[i], key, siglist[i]);
if (!result.Success)
{
return(new HssVerificationResult("LMS Validation failed: " + result.ErrorMessage));
}
key = publist[i];
}
// 3. return lms_verify(message, key, siglist[Nspk])
var finalResult = _lms[Nspk].VerifyLmsSignature(msg, key, siglist[Nspk]);
if (finalResult.Success)
{
return(new HssVerificationResult());
}
else
{
return(new HssVerificationResult("Validation failed. Final check failed: " + finalResult.ErrorMessage));
}
}
/// <summary>
/// A.1.2.2
/// </summary>
/// <param name="p"></param>
/// <param name="q"></param>
/// <param name="seed"></param>
/// <param name="count"></param>
/// <returns></returns>
public PQValidateResult Validate(BigInteger p, BigInteger q, DomainSeed seed, Counter count)
{
// 0, domain type check
if (seed.Mode != PrimeGenMode.Provable && count.Mode != PrimeGenMode.Provable)
{
return(new PQValidateResult("Invalid DomainSeed and Counter"));
}
// 1, 2
var L = new BitString(p).BitLength;
var N = new BitString(q).BitLength;
// 3
if (!DSAHelper.VerifyLenPair(L, N))
{
return(new PQValidateResult("Invalid L, N pair"));
}
// 4
if (seed.Seed < NumberTheory.Pow2(N - 1))
{
return(new PQValidateResult("Bad first seed"));
}
// 5
if (NumberTheory.Pow2(N) <= q)
{
return(new PQValidateResult("Bad q, too small"));
}
// 6
if (NumberTheory.Pow2(L) <= p)
{
return(new PQValidateResult("Bad p, too large"));
}
// 7
if ((p - 1) % q != 0)
{
return(new PQValidateResult("p - 1 % q != 0, bad values"));
}
// 8
var computed_result = Generate(L, N, seed.Seed);
if (!computed_result.Success)
{
return(new PQValidateResult("Failed to generate p and q"));
}
if (q != computed_result.Q || seed.QSeed != computed_result.Seed.QSeed || count.QCount != computed_result.Count.QCount)
{
return(new PQValidateResult("Failed to generate given q"));
}
if (p != computed_result.P || seed.PSeed != computed_result.Seed.PSeed || count.PCount != computed_result.Count.PCount)
{
return(new PQValidateResult("Failed to generate given p"));
}
return(new PQValidateResult());
}
/**
* Created a JPEG image from the specified BitmapData
*
* @param image The BitmapData that will be converted into the JPEG format.
* @return a ByteArray representing the JPEG encoded image data.
* @langversion ActionScript 3.0f
* @playerversion Flash 9.0f
* @tiptext
*/
private void Encode()
{
// Initialize bit writer
byteout = new ByteArray();
bytenew=0;
bytepos=7;
// Add JPEG headers
WriteWord(0xFFD8); // SOI
WriteAPP0();
WriteDQT();
WriteSOF0(image.width,image.height);
WriteDHT();
writeSOS();
// Encode 8x8 macroblocks
float DCY=0;
float DCU=0;
float DCV=0;
bytenew=0;
bytepos=7;
for (int ypos = 0; ypos < image.height; ypos += 8 )
{
for (int xpos = 0; xpos < image.width; xpos += 8)
{
RGB2YUV(image, xpos, ypos);
DCY = ProcessDU(YDU, fdtbl_Y, DCY, YDC_HT, YAC_HT);
DCU = ProcessDU(UDU, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
DCV = ProcessDU(VDU, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
//If running on a single core system, then give some time to do other stuff
if( cores == 1 )
Thread.Sleep(0);
}
}
// Do the bit alignment of the EOI marker
if ( bytepos >= 0 )
{
BitString fillbits = new BitString();
fillbits.length = bytepos+1;
fillbits.value = (1<<(bytepos+1))-1;
WriteBits(fillbits);
}
WriteWord(0xFFD9); //EOI
//Signal we are done
isDone = true;
}
public void AddEntropy(BitString entropy)
{
_entropy.AddEntropy(entropy);
}
public CertificationRequest(CertificationRequestInfo certificationRequestInfo, AlgorithmIdentifier signatureAlgorithm, BitString signature)
: base(certificationRequestInfo, signatureAlgorithm, signature)
{
}
public SubjectPublicKeyInfo(AlgorithmIdentifier algorithm, BitString subjectPublicKey) : base(algorithm, subjectPublicKey)
{
}
public void OtherInfoProofOfConceptTests(OtherPartySharedInformation <FfcDomainParameters, FfcKeyPair> uPartySharedInformation, int otherInfoLength, string otherInfoPattern, BitString expectedBitString)
{
var vPartySharedInformation = new OtherPartySharedInformation <FfcDomainParameters, FfcKeyPair>(
null,
new BitString(0),
new FfcKeyPair(0),
new FfcKeyPair(0),
new BitString(0),
new BitString(0),
new BitString(0)
);
var uPartyOtherInfo = new PartyOtherInfo(uPartySharedInformation.PartyId, uPartySharedInformation.DkmNonce);
var vPartyotherInfo = new PartyOtherInfo(vPartySharedInformation.PartyId, vPartySharedInformation.DkmNonce);
_subject = new OtherInfo(
new EntropyProvider(new Random800_90()),
otherInfoPattern,
otherInfoLength,
KeyAgreementRole.InitiatorPartyU,
uPartyOtherInfo,
vPartyotherInfo
);
var result = _subject.GetOtherInfo();
Assert.AreEqual(expectedBitString.ToHex(), result.ToHex());
}
public void SetLane(int x, int y, BitString lane)
{
_state[x, y] = BitStringToLong(lane);
}
public BitString(BitString src)
{
Value = src.Value;
TrailBitsCnt = src.getTrailBitsCnt();
}
public void ExactBitLengthShouldTakeAllBitsAfterMostSignificantBit(string hex, int expectedResult)
{
var value = new BitString(hex).ToPositiveBigInteger();
Assert.AreEqual(expectedResult, value.ExactBitLength());
}
public void Bug1011321WrongBitStringvalue2()
{
var b = new BitString(true, 6);
Assert.AreEqual("111111", b.ToString());
}
public BitString RandomizeMessage(BitString message, int randomizationSecurityStrength)
{
var rv = _entropyProvider.GetEntropy(randomizationSecurityStrength);
BitString padding = BitString.One();
// from https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-106.pdf
/*
* 1. If(| Ms | ≥ (| rv | -1))
* {
* 1.1 padding = 1.
* }
* Else
* {
* 1.2 padding = 1 || 0(| rv | - | Ms | -1).
* }
*/
if (message.BitLength < rv.BitLength - 1)
{
padding = padding.ConcatenateBits(BitString.Zeroes(rv.BitLength - message.BitLength - 1));
}
// 2. m = Ms || padding.
var m = message.ConcatenateBits(padding);
// 3. n is a positive integer, and n = | rv |.
var n = rv.BitLength;
// 4. If(n > 1024) then stop and output an error indicator(see Section 3.3).
if (n < 80 || n > 1024)
{
throw new ArgumentOutOfRangeException(nameof(n));
}
// 5. counter = ⎣| m | / n⎦.
var counter = (int)System.Math.Floor((double)m.BitLength / n);
// 6. remainder = (| m | mod n).
var remainder = m.BitLength % n;
/*
* 7. Concatenate counter copies of the rv to the remainder left - most bits of the rv to get Rv,
* such that | Rv | = | m |.
*/
var Rv = new BitString(0);
for (var i = 0; i < counter; i++)
{
Rv = Rv.ConcatenateBits(rv);
}
Rv = Rv.ConcatenateBits(rv.GetLeastSignificantBits(remainder));
// Sanity check
if (Rv.BitLength != m.BitLength)
{
throw new ArgumentOutOfRangeException(nameof(Rv));
}
/*
* 8. Convert n to a 16 - bit binary string rv_length_indicator using the
* rv_length_indicator_generation function specified in the Appendix.
* rv_length_indicator = rv_length_indicator_generation(n).
*/
// this cast should be safe as we're ensuring n <= 1024
var nBitString = BitString.To16BitString((short)n);
//9. M = rv || (m ⊕ Rv) || rv_length_indicator(Figure 1).
return(rv
.ConcatenateBits(m.XOR(Rv))
.ConcatenateBits(nBitString));
}
private BitString[] computeHuffmanTbl(int[] nrcodes, int[] std_table)
{
int codevalue = 0;
int pos_in_table = 0;
BitString[] HT = new BitString[16 * 16];
for ( int k = 1; k <= 16; k++ )
{
for ( int j = 1; j <= nrcodes[k]; j++ )
{
HT[std_table[pos_in_table]] = new BitString();
HT[std_table[pos_in_table]].val = codevalue;
HT[std_table[pos_in_table]].len = k;
pos_in_table++;
codevalue++;
}
codevalue *= 2;
}
return HT;
}
/// <summary>
/// Writes a bit string value to the buffer.
/// </summary>
private int WriteField(TsCCpxContext context, BitString field, object fieldValue, ref byte bitOffset)
{
byte[] buffer = context.Buffer;
// initialize serialization paramters.
int bits = (field.LengthSpecified) ? (int)field.Length : 8;
int length = (bits % 8 == 0) ? bits / 8 : bits / 8 + 1;
if (fieldValue.GetType() != typeof(byte[]))
{
throw new TsCCpxInvalidDataToWriteException("Wrong data type to write.");
}
// allocate space for the value.
byte[] bytes = (byte[])fieldValue;
if (buffer != null)
{
// check if there is enough data left.
if (buffer.Length - context.Index < length)
{
throw new TsCCpxInvalidDataToWriteException("Unexpected end of buffer.");
}
int bitsLeft = bits;
byte mask = (bitOffset == 0) ? (byte)0xFF : (byte)((0x80 >> (bitOffset - 1)) - 1);
// loop until all bits read.
for (int ii = 0; bitsLeft >= 0 && ii < length; ii++)
{
// add the bits from the lower byte.
buffer[context.Index + ii] += (byte)((mask & ((1 << bitsLeft) - 1) & bytes[ii]) << bitOffset);
// check if no more bits need to be read.
if (bitsLeft + bitOffset <= 8)
{
break;
}
// check if possible to read the next byte.
if (context.Index + ii + 1 >= buffer.Length)
{
throw new TsCCpxInvalidDataToWriteException("Unexpected end of buffer.");
}
// add the bytes from the higher byte.
buffer[context.Index + ii + 1] += (byte)((~mask & ((1 << bitsLeft) - 1) & bytes[ii]) >> (8 - bitOffset));
// check if all done.
if (bitsLeft <= 8)
{
break;
}
// decrement the bit count.
bitsLeft -= 8;
}
}
// update the length bit offset.
length = (bits + bitOffset) / 8;
bitOffset = (byte)((bits + bitOffset) % 8);
// return the bytes read.
return(length);
}
private void initCategoryfloat()
{
int nrlower = 1;
int nrupper = 2;
int nr;
BitString bs;
for ( int cat = 1; cat <= 15; cat++ )
{
//Positive numbers
for ( nr = nrlower; nr < nrupper; nr++ )
{
category[32767 + nr] = cat;
bs = new BitString();
bs.len = cat;
bs.val = nr;
bitcode[32767 + nr] = bs;
}
//Negative numbers
for ( nr = -(nrupper - 1); nr <= -nrlower; nr++ )
{
category[32767 + nr] = cat;
bs = new BitString();
bs.len = cat;
bs.val = nrupper - 1 + nr;
bitcode[32767 + nr] = bs;
}
nrlower <<= 1;
nrupper <<= 1;
}
}
public KdfResult DeriveKey(BitString z, int keyDataLength, BitString otherInfo, BitString salt)
{
// change the z prior to passing to the KDF
z[0] += 2;
return(_kdf.DeriveKey(z, keyDataLength, otherInfo, salt));
}
private void writeBits(BitString bs)
{
int value = bs.val;
int posval = bs.len - 1;
while ( posval >= 0 )
{
if ( ((uint)value & System.Convert.ToUInt32(1 << posval)) != 0 )
{
bytenew |= (int)(System.Convert.ToUInt32(1 << bytepos));
}
posval--;
bytepos--;
if ( bytepos < 0 )
{
if ( bytenew == 0xFF )
{
writeByte(0xFF);
writeByte(0);
}
else
{
writeByte((byte)bytenew);
}
bytepos = 7;
bytenew = 0;
}
}
}
/**
* Created a JPEG image from the specified BitmapData
*
* @param image The BitmapData that will be converted into the JPEG format.
* @return a ByteArray representing the JPEG encoded image data.
* @langversion ActionScript 3.0f
* @playerversion Flash 9.0f
* @tiptext
*/
private void Encode()
{
// Initialize bit writer
mainBuffer = new ByteArray();
bytenew=0;
bytepos=7;
// Add JPEG headers
WriteWord(0xFFD8); // SOI
WriteAPP0();
WriteDQT();
WriteSOF0(image.width,image.height);
WriteDHT();
WriteDRI();
WriteSOS();
// Encode 8x8 macroblocks
float DCY=0;
float DCU=0;
float DCV=0;
bytenew=0;
bytepos=7;
int count = 0;
int numberOfBlocks = 0;
taskQueue = new Queue<Task>();
completedTasks = new SortedList<int, Task>();
List<int> xposCollection = new List<int>();
List<int> yposCollection = new List<int>();
for (int ypos = 0; ypos < image.height; ypos += 8 )
{
for (int xpos = 0; xpos < image.width; xpos += 8)
{
xposCollection.Add( xpos );
yposCollection.Add( ypos );
// RGB2YUV(image, xpos, ypos);
// DCY = ProcessDU(YDU, fdtbl_Y, DCY, YDC_HT, YAC_HT, ref output, ref bytepos, ref bytenew);
// DCU = ProcessDU(UDU, fdtbl_UV, DCU, UVDC_HT, UVAC_HT, ref output, ref bytepos, ref bytenew);
// DCV = ProcessDU(VDU, fdtbl_UV, DCV, UVDC_HT, UVAC_HT, ref output, ref bytepos, ref bytenew);
//
// Debug.Log( numberOfBlocks );
numberOfBlocks++;
if( numberOfBlocks == resetInterval)
{
numberOfBlocks = 0;
// Debug.Log(blockNumber);
// WriteWord(0xFFD0 + blockNumber, ref output);
//
// blockNumber = ++blockNumber % 8;
//
// bytenew=0;
// bytepos=7;
// DCY = 0;
// DCU = 0;
// DCV = 0;
count++;
taskQueue.Enqueue( new Task(count, xposCollection, yposCollection ) );
xposCollection.Clear();
yposCollection.Clear();
}
//
// //If running on a single core system, then give some time to do other stuff
// if( cores == 1 )
// Thread.Sleep(0);
}
}
System.DateTime dt = System.DateTime.Now;
ThreadStart threadStart = delegate { ProcessTask(); };
Thread worker = new Thread(threadStart);
worker.IsBackground = true;
worker.Start();
ThreadStart threadStart2 = delegate { ProcessTask(); };
Thread worker2 = new Thread(threadStart2);
worker2.IsBackground = true;
worker2.Start();
ThreadStart threadStart3 = delegate { ProcessTask(); };
Thread worker3 = new Thread(threadStart3);
worker3.IsBackground = true;
worker3.Start();
ThreadStart threadStart4 = delegate { ProcessTask(); };
Thread worker4 = new Thread(threadStart4);
worker4.IsBackground = true;
worker4.Start();
// Thread worker3 = new Thread(ProcessTask);
// worker3.Start();
worker.Join();
worker2.Join();
worker3.Join();
worker4.Join();
Debug.Log(worker.IsAlive);
// Thread.Sleep(1000);
Debug.Log("WorkDone : " + (System.DateTime.Now - dt));
// mainBuffer.WriteBuffer(output.GetAllBytes());
Debug.Log("Number of reset words: " + count);
//Merge everything
foreach(KeyValuePair<int, Task> kvp in completedTasks)
{
// Debug.Log(kvp.Key);
mainBuffer.WriteBuffer( kvp.Value.buffer.GetAllBytes() );
}
// Do the bit alignment of the EOI marker
if ( bytepos >= 0 )
{
BitString fillbits = new BitString();
fillbits.length = bytepos+1;
fillbits.value = (1<<(bytepos+1))-1;
WriteBits(fillbits);
}
WriteWord(0xFFD9); //EOI
//Signal we are done
isDone = true;
}
