public bool readFromStream(FileStream stream)
{
byte[] buffer = new byte[length];
int result = stream.Read(buffer, 0, buffer.Length);
if (result != buffer.Length)
{
return(false);
}
MemoryInputStream ms = new MemoryInputStream(buffer, isLittleEndian);
timestampDelta = (byte)ms.ReadByte();
force = ms.readInt16();
x = ms.readInt16() & 0xffff;
y = ms.readInt16() & 0xffff;
fx = ms.ReadByte() & 0xff;
fy = ms.ReadByte() & 0xff;
xTilt = (byte)ms.ReadByte();
yTilt = (byte)ms.ReadByte();
twist = ms.readInt16();
labelCount = (byte)ms.ReadByte();
brightnessAndProcessTime = (byte)ms.ReadByte();
checkSum = (byte)ms.ReadByte();
byte sum = ms.getByteCheckSum(0, buffer.Length - 1);
return(sum == checkSum);
}
public bool readFromStream(FileStream stream)
{
byte[] buffer = new byte[length];
int result = stream.Read(buffer, 0, buffer.Length);
if (result != buffer.Length)
{
return(false);
}
MemoryInputStream ms = new MemoryInputStream(buffer, isLittleEndian);
downTime = ms.readInt64();
upTimeFromDownTime = ms.readInt32();
pageId = ms.readInt32();
status = (byte)ms.ReadByte();
penTipType = (byte)ms.ReadByte();
penTipColor = ms.readInt32();
codeTableFileNumber = ms.readInt16();
codeTableFileOffset = ms.readInt32();
codeCount = ms.readInt16();
successRate = (byte)ms.ReadByte();
checkSum = (byte)ms.ReadByte();
byte sum = ms.getByteCheckSum(0, buffer.Length - 1);
return(sum == checkSum);
}
/// <summary>
/// Tests the code128 C.
/// </summary>
/// <externalUnit/>
/// <revision revisor="dev13" date="11/19/2009" version="1.1.3.7">
/// Added documentation header
/// </revision>
private static void TestCode128C()
{
string text = "98723493871103000000";
Bitmap barcode = Code128.Encode(text, 1, 0.125F, 96, 12, 0);
PixelChar.DrawChar(barcode, 'M', 0, 2);
Bitmap pixelchar = new Bitmap(70, 40);
Graphics g = Graphics.FromImage(pixelchar);
g.Clear(Color.White);
g.Dispose();
pixelchar.SetResolution(96, 96);
for (int i = 0; i < 7; i++)
{
for (int j = 0; j < 4; j++)
{
if (j * 7 + i < 26)
{
char ch = (char)(j * 7 + i + 65);
PixelChar.DrawChar(pixelchar, ch, 10 * i, 10 * j);
}
}
}
MemoryInputStream misStream = new MemoryInputStream(barcode, 100);
barcode.Dispose();
barcode.Dispose();
DSxInput pdfInput = new DSxInput(misStream);
DSxSystem.setLicenseKey(
"[Insert your license key here]");
DSxTask task = new DSxTask();
PDFxDocument pdfDoc = PDF.createDocument(task);
PDFxContext context = pdfDoc.getContext();
PDFxPage pdfPage = pdfDoc.createCustomPage(5, 2);
PDFxImage bar = PDFxImage.createImageFromJPEG(pdfInput);
double dpi = 96D,
k = 72D / dpi;
pdfPage.drawImage(
18, 18, k * bar.getWidth(), k * bar.getHeight(), bar);
bar =
PDFxImage.createImageFromJPEG(
new DSxInput(new MemoryInputStream(pixelchar, 100)));
pixelchar.Dispose();
pdfPage.drawImage(
18, 72, k * bar.getWidth(), k * bar.getHeight(), bar);
DSxPDFDocument dsDocument = new DSxPDFDocument(pdfDoc);
dsDocument.save(new DSxOutput(@"bin\Debug\DSxInput2.pdf"));
}
public void ReadByte_EndOfStream_ReturnEndOfStreamIntCode()
{
// Arrange
const int endOfFileCode = -1;
IInputStream memoryInputStream = new MemoryInputStream(new byte[0]);
// Act
int result = memoryInputStream.ReadByte();
memoryInputStream.Dispose();
// Assert
Assert.Equal(endOfFileCode, result);
}
public void ReadBlock_EndOfStream_ReadDataSizeEqualsZero()
{
// Arrange
const int expectedResult = 0;
IInputStream memoryInputStream = new MemoryInputStream(new byte[0]);
// Act
int result = memoryInputStream.ReadBlock(buffer: new byte[1], count: 1);
memoryInputStream.Dispose();
// Assert
Assert.Equal(expectedResult, result);
}
public void ReadByte_StreamWithData_ReturnFirstByte()
{
// Arrange
const int expectedResult = 0x31;
IInputStream memoryInputStream = new MemoryInputStream(new byte[] { 0x31, 0x32 });
// Act
int result = memoryInputStream.ReadByte();
memoryInputStream.Dispose();
// Assert
Assert.Equal(expectedResult, result);
}
public void ReadBlock_StreamWithData_ReturnData()
{
// Arrange
const int expectedReadSize = 3;
var expectedBuffer = new byte[] { 0x31, 0x32, 0x33 };
IInputStream memoryInputStream = new MemoryInputStream(new byte[] { 0x31, 0x32, 0x33 });
// Act
var buffer = new byte[3];
int readSize = memoryInputStream.ReadBlock(buffer, count: 3);
memoryInputStream.Dispose();
// Assert
Assert.Equal(expectedReadSize, readSize);
Assert.Equal(expectedBuffer, buffer);
}
public CmsTypedStream GetContentStream(IDecryptorBuilderProvider <AlgorithmIdentifier> inputDecryptorProvider)
{
try
{
EncryptedContentInfo encContentInfo = encryptedData.EncryptedContentInfo;
ICipherBuilder <AlgorithmIdentifier> decryptorBuilder = inputDecryptorProvider.CreateDecryptorBuilder(encContentInfo.ContentEncryptionAlgorithm);
MemoryInputStream encIn = new MemoryInputStream(encContentInfo.EncryptedContent.GetOctets());
ICipher cipher = decryptorBuilder.BuildCipher(encIn);
return(new CmsTypedStream(encContentInfo.ContentType, cipher.Stream));
}
catch (Exception e)
{
throw new CmsException("unable to create stream: " + e.Message, e);
}
}
private Constant LoadConstantValue(byte[] metaConstantValue)
{
if (metaConstantValue == null)
{
return(null);
}
using var memoryInputStream = new MemoryInputStream(metaConstantValue);
using var ms = new DataInputStream(memoryInputStream);
var constant = Constant.ReadConstant(ms);
//Read the actual string from the data and create a constant pool for it.
if (constant is ConstantString constantString)
{
var originalString = ms.ReadUtfAndIntern();
_metaConstantPool = new ConstantPool(new Constant[] { new ConstantUtf8(originalString) });
constantString.SetStringIndex(0);
}
return(constant);
}
public object Decrypt(IDecryptorBuilderProvider <DekInfo> keyDecryptorProvider)
{
try
{
ICipherBuilder <DekInfo> decryptorBuilder = keyDecryptorProvider.CreateDecryptorBuilder(new DekInfo(dekInfo));
MemoryInputStream bOut = new MemoryInputStream(keyBytes);
ICipher decryptor = decryptorBuilder.BuildCipher(bOut);
using (var stream = decryptor.Stream)
{
return(parser.Parse(Streams.ReadAll(stream)));
}
}
catch (IOException e)
{
throw e;
}
catch (Exception e)
{
throw new OpenSslPemParsingException("exception processing key pair: " + e.Message, e);
}
}
public bool readFromStream(FileStream stream)
{
byte[] buffer = new byte[length];
int result = stream.Read(buffer, 0, buffer.Length);
if (result != buffer.Length)
{
return(false);
}
isLittleEndian = buffer[endianByteIndex] != 0;
MemoryInputStream ms = new MemoryInputStream(buffer, isLittleEndian);
fileType = (byte)ms.ReadByte();
if ((char)fileType != 'C')
{
return(false);
}
version = ms.readInt16();
fileNumber = ms.readInt16();
long n = ms.readInt64();
sectionId = (int)(n >> 56);
ownerId = (int)(n >> 32) & 0x00ffffff;
noteId = (int)(n & 0xffffffff);
ms.Read(macAddress, 0, macAddress.Length);
ms.Read(reserved, 0, reserved.Length);
checkSum = (byte)ms.ReadByte();
byte sum = ms.getByteCheckSum(0, buffer.Length - 1);
return(sum == checkSum);
}
/// <summary>
/// Verify<br />
/// </summary>
/// <param name="userId"></param>
/// <param name="privateKey"></param>
/// <param name="sourceData"></param>
/// <param name="signData"></param>
/// <returns></returns>
public static bool Verify2(byte[] userId, byte[] privateKey, byte[] sourceData, byte[] signData)
{
if (privateKey is null || privateKey.Length == 0)
{
return(false);
}
if (sourceData is null || sourceData.Length == 0)
{
return(false);
}
SM2Core sm2 = SM2Core.Instance;
ECPoint userKey = sm2.ecc_curve.DecodePoint(Hex.Encode(privateKey));
SM2Core.SM2_SM3Digest sm3 = new SM2Core.SM2_SM3Digest();
byte[] z = sm2.Sm2GetZ(userId, userKey);
sm3.BlockUpdate(z, 0, z.Length);
sm3.BlockUpdate(sourceData, 0, sourceData.Length);
byte[] md = new byte[32];
sm3.DoFinal(md, 0);
MemoryInputStream bis = new MemoryInputStream(signData);
Asn1InputStream dis = new Asn1InputStream(bis);
Asn1Object derObj = dis.ReadObject();
var e = (Asn1Sequence)derObj;
DerInteger r = (DerInteger)e[0];
DerInteger s = (DerInteger)e[1];
SM2Result sm2Result = new SM2Result();
sm2Result.r = r.PositiveValue;
sm2Result.s = s.PositiveValue;
sm2.Sm2Verify(md, userKey, sm2Result.r, sm2Result.s, sm2Result);
return(sm2Result.r.Equals(sm2Result.R));
}
