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 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; }