C# Hash SHA256Managed is not equal to TSQL SHA2_256 - c#

I am using hashed passwords with a salt (the username).
Problem is that the hashed values of c# are not equal to the initial values I add to the database by a TSQL Script.
TSQL:
UPDATE [Users]
SET Password = HASHBYTES('SHA2_256', 'test123'+UPPER([UserName]))
GO;
C#:
var passBytes = new UnicodeEncoding().GetBytes(pass);
var saltBytes = new UnicodeEncoding().GetBytes(userName.ToUpper());
var dataToHash = new byte[passBytes.Length + saltBytes.Length];
Array.Copy(passBytes, dataToHash, passBytes.Length);
Array.Copy(saltBytes, dataToHash, saltBytes.Length);
var sha = new SHA256Managed();
return sha.ComputeHash(dataToHash);
I guess it has something to do with the encoding.
But i have no idea how to fix this.
UserName is varchar(50)
The DB is an existing one so changing the varchar will not be so easy.
I already tried:
UPDATE [Users]
SET Password = HASHBYTES('SHA2_256', N'test123'+UPPER([UserName]))
GO;


After struggling to get this to work, here is a sample of what I finally got to work:
public string Hash(string input)
{
using (SHA256 hasher = SHA256.Create())
{
// Convert the input string to a byte array and compute the hash.
byte[] data = hasher.ComputeHash(Encoding.Unicode.GetBytes(input));
// Create a new Stringbuilder to collect the bytes
// and create a string.
StringBuilder sBuilder = new StringBuilder();
// Loop through each byte of the hashed data
// and format each one as a hexadecimal string.
for (int i = 0; i < data.Length; i++)
{
sBuilder.Append(data[i].ToString("X2"));
}
// Return the hexadecimal string.
return sBuilder.ToString();
}
}
TSQL
declare #input as nvarchar(max) = 'Test';
select #input;
declare #hash as varbinary(max) = HASHBYTES('SHA2_256', #input );
select #hash;
declare #result as nvarchar(max) = CONVERT(NVARCHAR(MAX), #hash, 2);
select #result;
These will produce identical results.
Note that this is using a nvarchar datatype, not a varchar.


If your SQL Server database is configured to use the default collation of SQL_Latin1_General_CP1_CI_AS, then in your C# code, use code page 1252 to convert characters to bytes. Thus, the equivalent of
HASHBYTES('SHA2_256', 'test123' + UPPER([UserName]))
is
byte[] data = Encoding.GetEncoding(1252).GetBytes("test123" + userName.ToUpper());
var sha = new SHA256Managed();
byte[] hash = sha.ComputeHash(data);


Hashes work on bytes, not on characters. What you're doing is Hash(StringToBytes(str)). Your StringToBytes step is different. In SQL you are using ANSI varchar strings and in C# UTF-16 strings. Decide which one you want and use that. I recommend Unicode (nvarchar).


Encoding.UTF8.GetBytes(input) = HASHBYTES('SHA2_256', #varcharVariable);
Encoding.Unicode.GetBytes(input) = HASHBYTES('SHA2_256', #nvarcharVariable);

Related

how to compute a hash in C# with the correct coding?

when I get a hash from C# I seem to get a different value then when I do it in sql server.
Take this query
declare #test table (value nvarchar(100))
insert into #test values ('1234'), (N'1234')
select 'from db' as source, t.value, HASHBYTES('SHA2_256', t.value) as result from #test t
union all
select 'fixed ascii', '1234', HASHBYTES('SHA2_256', '1234')
union all
select 'fixed unicode', N'1234', HASHBYTES('SHA2_256', N'1234')
the result is
source
value
result
from db
1234
0x4F37C061F1854F9682F543FECB5EE9D652C803235970202DE97C6E40C8361766
from db
1234
0x4F37C061F1854F9682F543FECB5EE9D652C803235970202DE97C6E40C8361766
fixed ascii
1234
0x03AC674216F3E15C761EE1A5E255F067953623C8B388B4459E13F978D7C846F4
fixed unicode
1234
0x4F37C061F1854F9682F543FECB5EE9D652C803235970202DE97C6E40C8361766
As you can see in the result, only the fixed ascii version has a different result, as I would also expect since the column has datatype nvarchar
Now I want to get the hash in C#
private string GetStringSha256Hash(string text, System.Text.Encoding coding)
{
string result = "";
if (String.IsNullOrEmpty(text) == false)
{
using (var sha = new System.Security.Cryptography.SHA256Managed())
{
byte[] textData = coding.GetBytes(text);
byte[] hash = sha.ComputeHash(textData);
result = BitConverter.ToString(hash).Replace("-", String.Empty);
}
}
return result;
}
string dbPass = TextEditPass.Text;
string hashedPassUTF8 = GetStringSha256Hash(dbPass, System.Text.Encoding.UTF8);
string hashedPassASCII = GetStringSha256Hash(dbPass, System.Text.Encoding.ASCII);
The result is the same for each call to GetStringSha256Hash
03AC674216F3E15C761EE1A5E255F067953623C8B388B4459E13F978D7C846F4
and it is the same as the ascii result from the database.
So my question is, how can I do it in C# do get the unicode result, when I have to start from the value of a simple textBox ?
I just want to make sure that the C# application will never say a value from the DB is not correct because of differences in text encoding.

Getting issue when convert c# code to PHP as below

I am running this code:
var timeStamp = DateTime.UtcNow;
var sharedSecret = "xx";
var saltedString = timeStamp.ToString("2021-01-07T16:42:33.619667Z") + sharedSecret;
//Encoding saltedString using Unicode little-endian byte order
byte[] encodedSaltedString = Encoding.Unicode.GetBytes(saltedString);
//Hashing Algorithm used is SHA512
HashAlgorithm hash = new SHA512Managed();
//Compute Hash of encodedSaltedString
byte[] hashedEncodedString = hash.ComputeHash(encodedSaltedString);
//Convert hashed array to base64-encoded string
string signature = Convert.ToBase64String(hashedEncodedString);
I am then getting this result in C#:
"gQhjrLnY6fo44EeaaWaUBE1PY/8oEIRsUcK3AMSCVUCYMM4vRfxvQEEggXaHTF0GQbw4w2HbWArX1k6NnkzJFg=="
I converted to this code as below, but I am getting an issue. Can I get some help on this?
$timestamp = "2021-01-07T16:42:33.619667Z";
$sharedSecret = 'xx';
$saltedString = $timestamp.$sharedSecret;
$utf=mb_convert_encoding($saltedString, "UTF-16LE");
$signature = base64_encode(hash('sha512', $utf));
IN PHP I am getting this result:
ODEwODYzYWNiOWQ4ZTlmYTM4ZTA0NzlhNjk2Njk0MDQ0ZDRmNjNmZjI4MTA4NDZjNTFjMmI3MDBjNDgyNTU0MDk4MzBjZTJmNDVmYzZmNDA0MTIwODE3Njg3NGM1ZDA2NDFiYzM4YzM2MWRiNTgwYWQ3ZDY0ZThkOWU0Y2M5MTY=
But both should be same. The c# one is correct, I want the same in the php code as well.

From the PHP docs for hash:
hash ( string $algo , string $data , bool $binary = false ) : string|false
binary
   When set to true, outputs raw binary data. false outputs lowercase hexits.
You're not passing a value for $binary, so it's returning a string of hexadecimal characters.
The C# HashAlgorithm.ComputeHash method on the other hand binary data.
Since you're base64-encoding the result, you're presumably expecting the hash function to return binary data. You therefore need to pass true as the value for $binary:
$signature = base64_encode(hash('sha512', $utf, true));

I cannot create a md5-hash code with T-SQL like in C#

I'm posting data to a web service.
But before I send the data to the web service, I have to get the md5-hash code and add it to the soap data.
For the code in #sendData, I am expected to generate the md5-hash code
58a457d0b2e566048e0a2a046bd68045
declare #sendData varchar(max)='<?xml version="1.0" encoding="UTF-8"?>
<Invoice
    xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2"
    xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2"
    xmlns:udt="urn:un:unece:uncefact:data:specification:UnqualifiedDataTypesSchemaModule:2"
    xmlns:ccts="urn:un:unece:uncefact:documentation:2"
    xmlns:ext="urn:oasis:names:specification:ubl:schema:xsd:CommonExtensionComponents-2"
    xmlns:qdt="urn:oasis:names:specification:ubl:schema:xsd:QualifiedDatatypes-2"
    xmlns:ubltr="urn:oasis:names:specification:ubl:schema:xsd:TurkishCustomizationExtensionComponents"
    xmlns:ds="http://www.w3.org/2000/09/xmldsig#"          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2 UBL-Invoice-2.1.xsd"
    xmlns:xades="http://uri.etsi.org/01903/v1.3.2#" xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
    <ext:UBLExtensions>
        <ext:UBLExtension>
            <ext:ExtensionContent/>
        </ext:UBLExtension>
    </ext:UBLExtensions>
    <cbc:UBLVersionID>2.1</cbc:UBLVersionID>
    <cbc:CustomizationID>TR1.2</cbc:CustomizationID>
    <cbc:ProfileID>TICARIFATURA</cbc:ProfileID>
    <cbc:ID/>
    <cbc:CopyIndicator>false</cbc:CopyIndicator>
    <cbc:UUID>104E99B1-C11A-4447-8193-5BD40C384C2D</cbc:UUID>
    <cbc:IssueDate>2018-09-14</cbc:IssueDate>
    <cbc:InvoiceTypeCode>SATIS</cbc:InvoiceTypeCode>
    <cbc:Note>Sicil No: 33333, İşletme Merkezi: İstanbul</cbc:Note>
    <cbc:DocumentCurrencyCode>USD</cbc:DocumentCurrencyCode>
    <cbc:AccountingCost/>
    <cbc:LineCountNumeric>1</cbc:LineCountNumeric>

    <cac:Signature>
        <cbc:ID schemeID="VKN_TCKN">0201830512</cbc:ID>
        <cac:SignatoryParty>
            <cac:PartyIdentification>
                <cbc:ID schemeID="VKN">0201830512</cbc:ID>
            </cac:PartyIdentification>
            <cac:PostalAddress>
                <cbc:CitySubdivisionName>Mecidiyeköy</cbc:CitySubdivisionName>
                <cbc:CityName>İSTANBUL</cbc:CityName>
                <cac:Country>
                    <cbc:Name>TÜRKİYE</cbc:Name>
                </cac:Country>
            </cac:PostalAddress>
        </cac:SignatoryParty>
        <cac:DigitalSignatureAttachment>
            <cac:ExternalReference>
                <cbc:URI>#Signature_AAA2018000000015</cbc:URI>
            </cac:ExternalReference>
        </cac:DigitalSignatureAttachment>
    </cac:Signature>
    <cac:AccountingSupplierParty>
        <cac:Party>
            <cac:PartyIdentification>
                <cbc:ID schemeID="VKN">0201830512</cbc:ID>
            </cac:PartyIdentification>
            <cac:PartyName>
                <cbc:Name>Rota 8043</cbc:Name>
            </cac:PartyName>
            <cac:PostalAddress>
                <cbc:CitySubdivisionName>Mecidiyeköy</cbc:CitySubdivisionName>
                <cbc:CityName>İSTANBUL</cbc:CityName>
                <cac:Country>
                    <cbc:Name>TÜRKİYE</cbc:Name>
                </cac:Country>
            </cac:PostalAddress>
            <cac:PartyTaxScheme>
                <cac:TaxScheme>
                    <cbc:Name>SARIYER</cbc:Name>
                </cac:TaxScheme>
            </cac:PartyTaxScheme>
            <cac:Contact>
                <cbc:ElectronicMail>bahar.durmus@efinans.com.tr</cbc:ElectronicMail>
            </cac:Contact>
        </cac:Party>
    </cac:AccountingSupplierParty>
    <cac:AccountingCustomerParty>
        <cac:Party>
            <cac:PartyIdentification>
                <cbc:ID schemeID="VKN">1201830512</cbc:ID>
            </cac:PartyIdentification>
            <cac:PartyName>
                <cbc:Name>Rota 8443</cbc:Name>
            </cac:PartyName>
            <cac:PostalAddress>
                <cbc:CitySubdivisionName>test</cbc:CitySubdivisionName>
                <cbc:CityName>tes</cbc:CityName>
                <cac:Country>
                    <cbc:Name>AVUSTRALYA OKYANUSU</cbc:Name>
                </cac:Country>
            </cac:PostalAddress>
            <cac:PartyTaxScheme>
                <cac:TaxScheme>
                    <cbc:Name>test</cbc:Name>
                </cac:TaxScheme>
            </cac:PartyTaxScheme>
        </cac:Party>
    </cac:AccountingCustomerParty>
    <cac:PaymentMeans>
        <cbc:PaymentMeansCode>20</cbc:PaymentMeansCode>
        <cbc:PaymentDueDate>2018-09-14</cbc:PaymentDueDate>
        <cbc:PaymentChannelCode>Kasa</cbc:PaymentChannelCode>
        <cbc:InstructionNote>test</cbc:InstructionNote>
        <cac:PayeeFinancialAccount>
            <cbc:ID>123</cbc:ID>
            <cbc:CurrencyCode>USD</cbc:CurrencyCode>
        </cac:PayeeFinancialAccount>
    </cac:PaymentMeans>
    <cac:AllowanceCharge>
        <cbc:ChargeIndicator>false</cbc:ChargeIndicator>
        <cbc:Amount currencyID="USD">1.00</cbc:Amount>
    </cac:AllowanceCharge>
    <cac:PricingExchangeRate>
        <cbc:SourceCurrencyCode>USD</cbc:SourceCurrencyCode>
        <cbc:TargetCurrencyCode>TRY</cbc:TargetCurrencyCode>
        <cbc:CalculationRate>5</cbc:CalculationRate>
    </cac:PricingExchangeRate>
    <cac:TaxTotal>
        <cbc:TaxAmount currencyID="USD">1.62</cbc:TaxAmount>
        <cac:TaxSubtotal>
            <cbc:TaxableAmount currencyID="USD">9.00</cbc:TaxableAmount>
            <cbc:TaxAmount currencyID="USD">1.62</cbc:TaxAmount>
            <cbc:Percent>18</cbc:Percent>
            <cac:TaxCategory>
                <cac:TaxScheme>
                    <cbc:Name>KDV</cbc:Name>
                    <cbc:TaxTypeCode>0015</cbc:TaxTypeCode>
                </cac:TaxScheme>
            </cac:TaxCategory>
        </cac:TaxSubtotal>
    </cac:TaxTotal>
    <cac:LegalMonetaryTotal>
        <cbc:LineExtensionAmount currencyID="USD">10.00</cbc:LineExtensionAmount>
        <cbc:TaxExclusiveAmount currencyID="USD">9.00</cbc:TaxExclusiveAmount>
        <cbc:TaxInclusiveAmount currencyID="USD">10.62</cbc:TaxInclusiveAmount>
        <cbc:AllowanceTotalAmount currencyID="USD">1.00</cbc:AllowanceTotalAmount>
        <cbc:ChargeTotalAmount currencyID="USD">0.00</cbc:ChargeTotalAmount>
        <cbc:PayableRoundingAmount currencyID="USD">0</cbc:PayableRoundingAmount>
        <cbc:PayableAmount currencyID="USD">10.62</cbc:PayableAmount>
    </cac:LegalMonetaryTotal>
    <cac:InvoiceLine>
        <cbc:ID>1</cbc:ID>
        <cbc:InvoicedQuantity unitCode="C62">10</cbc:InvoicedQuantity>
        <cbc:LineExtensionAmount currencyID="USD">9.00</cbc:LineExtensionAmount>
        <cac:AllowanceCharge>
            <cbc:ChargeIndicator>false</cbc:ChargeIndicator>
            <cbc:MultiplierFactorNumeric>0.1</cbc:MultiplierFactorNumeric>
            <cbc:SequenceNumeric>0</cbc:SequenceNumeric>
            <cbc:Amount currencyID="USD">1.00</cbc:Amount>
            <cbc:BaseAmount currencyID="USD">10.00</cbc:BaseAmount>
        </cac:AllowanceCharge>
        <cac:TaxTotal>
            <cbc:TaxAmount currencyID="USD">1.62</cbc:TaxAmount>
            <cac:TaxSubtotal>
                <cbc:TaxableAmount currencyID="USD">9.00</cbc:TaxableAmount>
                <cbc:TaxAmount currencyID="USD">1.62</cbc:TaxAmount>
                <cbc:Percent>18</cbc:Percent>
                <cac:TaxCategory>
                    <cac:TaxScheme>
                        <cbc:Name>KDV</cbc:Name>
                        <cbc:TaxTypeCode>0015</cbc:TaxTypeCode>
                    </cac:TaxScheme>
                </cac:TaxCategory>
            </cac:TaxSubtotal>
        </cac:TaxTotal>
        <cac:Item>
            <cbc:Name>1</cbc:Name>
            <cac:SellersItemIdentification>
                <cbc:ID>1</cbc:ID>
            </cac:SellersItemIdentification>
        </cac:Item>
        <cac:Price>
            <cbc:PriceAmount currencyID="USD">1</cbc:PriceAmount>
        </cac:Price>
    </cac:InvoiceLine>
</Invoice>
'
SELECT
CONVERT(CHAR(32), HashBytes('MD5', #sendData), 2) AS 'hashCode'
but as a result of this the md5-hash code returned is
4D5A74F92C5B7154247AF52AF3FD13D0
I tried entering #sendData data from many online md5-hash generation sites. T-SQL's hash code seems correct.
When I said you created the hash code incorrectly, they sent me C# code.
But I use classic ASP, Python, SQL Server T-SQL, can I create a hash code like here?
public static string GetMD5Hash(byte[] inputData)
{
MD5 md5Hash = new MD5CryptoServiceProvider();
byte[] data = md5Hash.ComputeHash(inputData);
StringBuilder sBuilder = new StringBuilder();
for (int i = 0; i < data.Length; i++)
{
sBuilder.Append(data[i].ToString("x2"));
}
return sBuilder.ToString();
}

The difference is caused by the fact that the C# code is not hashing the string itself, it is hashing the binary value that is encoded in base64 as that string.
string inputString = "<?xml version="1.0" encoding="UTF-8"?>
<Invoice
    xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2"
    xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2"
    xmlns:udt="urn:un:unece:uncefact:data:specification:UnqualifiedDataTypesSchemaModule:2"
    xmlns:ccts="urn:un:unece:uncefact:documentation:2"
    xmlns:ext="urn:oasis:names:specification:ubl:schema:xsd:CommonExtensionComponents-2"
    xmlns:qdt="urn:oasis:names:specification:ubl:schema:xsd:QualifiedDatatypes-2"
    xmlns:ubltr="urn:oasis:names:specification:ubl:schema:xsd:TurkishCustomizationExtensionComponents"
    xmlns:ds="http://www.w3.org/2000/09/xmldsig#"          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2 UBL-Invoice-2.1.xsd"
    xmlns:xades="http://uri.etsi.org/01903/v1.3.2#" xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
    <ext:UBLExtensions>
        <ext:UBLExtension>
            <ext:ExtensionContent/>
        </ext:UBLExtension>
    </ext:UBLExtensions>
    <cbc:UBLVersionID>2.1</cbc:UBLVersionID>
    <cbc:CustomizationID>TR1.2</cbc:CustomizationID>
    <cbc:ProfileID>TICARIFATURA</cbc:ProfileID>
    <cbc:ID/>
    <cbc:CopyIndicator>false</cbc:CopyIndicator>
    <cbc:UUID>104E99B1-C11A-4447-8193-5BD40C384C2D</cbc:UUID>
    <cbc:IssueDate>2018-09-14</cbc:IssueDate>
    <cbc:InvoiceTypeCode>SATIS</cbc:InvoiceTypeCode>
    <cbc:Note>Sicil No: 33333, İşletme Merkezi: İstanbul</cbc:Note>
    <cbc:DocumentCurrencyCode>USD</cbc:DocumentCurrencyCode>
    <cbc:AccountingCost/>
    <cbc:LineCountNumeric>1</cbc:LineCountNumeric>

    <cac:Signature>
        <cbc:ID schemeID="VKN_TCKN">0201830512</cbc:ID>
        <cac:SignatoryParty>
            <cac:PartyIdentification>
                <cbc:ID schemeID="VKN">0201830512</cbc:ID>
            </cac:PartyIdentification>
            <cac:PostalAddress>
                <cbc:CitySubdivisionName>Mecidiyeköy</cbc:CitySubdivisionName>
                <cbc:CityName>İSTANBUL</cbc:CityName>
                <cac:Country>
                    <cbc:Name>TÜRKİYE</cbc:Name>
                </cac:Country>
            </cac:PostalAddress>
        </cac:SignatoryParty>
        <cac:DigitalSignatureAttachment>
            <cac:ExternalReference>
                <cbc:URI>#Signature_AAA2018000000015</cbc:URI>
            </cac:ExternalReference>
        </cac:DigitalSignatureAttachment>
    </cac:Signature>
    <cac:AccountingSupplierParty>
        <cac:Party>
            <cac:PartyIdentification>
                <cbc:ID schemeID="VKN">0201830512</cbc:ID>
            </cac:PartyIdentification>
            <cac:PartyName>
                <cbc:Name>Rota 8043</cbc:Name>
            </cac:PartyName>
            <cac:PostalAddress>
                <cbc:CitySubdivisionName>Mecidiyeköy</cbc:CitySubdivisionName>
                <cbc:CityName>İSTANBUL</cbc:CityName>
                <cac:Country>
                    <cbc:Name>TÜRKİYE</cbc:Name>
                </cac:Country>
            </cac:PostalAddress>
            <cac:PartyTaxScheme>
                <cac:TaxScheme>
                    <cbc:Name>SARIYER</cbc:Name>
                </cac:TaxScheme>
            </cac:PartyTaxScheme>
            <cac:Contact>
                <cbc:ElectronicMail>bahar.durmus@efinans.com.tr</cbc:ElectronicMail>
            </cac:Contact>
        </cac:Party>
    </cac:AccountingSupplierParty>
    <cac:AccountingCustomerParty>
        <cac:Party>
            <cac:PartyIdentification>
                <cbc:ID schemeID="VKN">1201830512</cbc:ID>
            </cac:PartyIdentification>
            <cac:PartyName>
                <cbc:Name>Rota 8443</cbc:Name>
            </cac:PartyName>
            <cac:PostalAddress>
                <cbc:CitySubdivisionName>test</cbc:CitySubdivisionName>
                <cbc:CityName>tes</cbc:CityName>
                <cac:Country>
                    <cbc:Name>AVUSTRALYA OKYANUSU</cbc:Name>
                </cac:Country>
            </cac:PostalAddress>
            <cac:PartyTaxScheme>
                <cac:TaxScheme>
                    <cbc:Name>test</cbc:Name>
                </cac:TaxScheme>
            </cac:PartyTaxScheme>
        </cac:Party>
    </cac:AccountingCustomerParty>
    <cac:PaymentMeans>
        <cbc:PaymentMeansCode>20</cbc:PaymentMeansCode>
        <cbc:PaymentDueDate>2018-09-14</cbc:PaymentDueDate>
        <cbc:PaymentChannelCode>Kasa</cbc:PaymentChannelCode>
        <cbc:InstructionNote>test</cbc:InstructionNote>
        <cac:PayeeFinancialAccount>
            <cbc:ID>123</cbc:ID>
            <cbc:CurrencyCode>USD</cbc:CurrencyCode>
        </cac:PayeeFinancialAccount>
    </cac:PaymentMeans>
    <cac:AllowanceCharge>
        <cbc:ChargeIndicator>false</cbc:ChargeIndicator>
        <cbc:Amount currencyID="USD">1.00</cbc:Amount>
    </cac:AllowanceCharge>
    <cac:PricingExchangeRate>
        <cbc:SourceCurrencyCode>USD</cbc:SourceCurrencyCode>
        <cbc:TargetCurrencyCode>TRY</cbc:TargetCurrencyCode>
        <cbc:CalculationRate>5</cbc:CalculationRate>
    </cac:PricingExchangeRate>
    <cac:TaxTotal>
        <cbc:TaxAmount currencyID="USD">1.62</cbc:TaxAmount>
        <cac:TaxSubtotal>
            <cbc:TaxableAmount currencyID="USD">9.00</cbc:TaxableAmount>
            <cbc:TaxAmount currencyID="USD">1.62</cbc:TaxAmount>
            <cbc:Percent>18</cbc:Percent>
            <cac:TaxCategory>
                <cac:TaxScheme>
                    <cbc:Name>KDV</cbc:Name>
                    <cbc:TaxTypeCode>0015</cbc:TaxTypeCode>
                </cac:TaxScheme>
            </cac:TaxCategory>
        </cac:TaxSubtotal>
    </cac:TaxTotal>
    <cac:LegalMonetaryTotal>
        <cbc:LineExtensionAmount currencyID="USD">10.00</cbc:LineExtensionAmount>
        <cbc:TaxExclusiveAmount currencyID="USD">9.00</cbc:TaxExclusiveAmount>
        <cbc:TaxInclusiveAmount currencyID="USD">10.62</cbc:TaxInclusiveAmount>
        <cbc:AllowanceTotalAmount currencyID="USD">1.00</cbc:AllowanceTotalAmount>
        <cbc:ChargeTotalAmount currencyID="USD">0.00</cbc:ChargeTotalAmount>
        <cbc:PayableRoundingAmount currencyID="USD">0</cbc:PayableRoundingAmount>
        <cbc:PayableAmount currencyID="USD">10.62</cbc:PayableAmount>
    </cac:LegalMonetaryTotal>
    <cac:InvoiceLine>
        <cbc:ID>1</cbc:ID>
        <cbc:InvoicedQuantity unitCode="C62">10</cbc:InvoicedQuantity>
        <cbc:LineExtensionAmount currencyID="USD">9.00</cbc:LineExtensionAmount>
        <cac:AllowanceCharge>
            <cbc:ChargeIndicator>false</cbc:ChargeIndicator>
            <cbc:MultiplierFactorNumeric>0.1</cbc:MultiplierFactorNumeric>
            <cbc:SequenceNumeric>0</cbc:SequenceNumeric>
            <cbc:Amount currencyID="USD">1.00</cbc:Amount>
            <cbc:BaseAmount currencyID="USD">10.00</cbc:BaseAmount>
        </cac:AllowanceCharge>
        <cac:TaxTotal>
            <cbc:TaxAmount currencyID="USD">1.62</cbc:TaxAmount>
            <cac:TaxSubtotal>
                <cbc:TaxableAmount currencyID="USD">9.00</cbc:TaxableAmount>
                <cbc:TaxAmount currencyID="USD">1.62</cbc:TaxAmount>
                <cbc:Percent>18</cbc:Percent>
                <cac:TaxCategory>
                    <cac:TaxScheme>
                        <cbc:Name>KDV</cbc:Name>
                        <cbc:TaxTypeCode>0015</cbc:TaxTypeCode>
                    </cac:TaxScheme>
                </cac:TaxCategory>
            </cac:TaxSubtotal>
        </cac:TaxTotal>
        <cac:Item>
            <cbc:Name>1</cbc:Name>
            <cac:SellersItemIdentification>
                <cbc:ID>1</cbc:ID>
            </cac:SellersItemIdentification>
        </cac:Item>
        <cac:Price>
            <cbc:PriceAmount currencyID="USD">1</cbc:PriceAmount>
        </cac:Price>
    </cac:InvoiceLine>
</Invoice>
";
//byte[] inputData=Encoding.ASCII.GetBytes(inputString);
byte[] inputData = Convert.FromBase64String(inputString);
Console.WriteLine(GetMD5Hash(inputData));
To do the same thing in T-SQL, you can use something like this:
declare #sendData varchar(max)='<?xml version="1.0" encoding="UTF-8"?>
<Invoice
    xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2"
    xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2"
    xmlns:udt="urn:un:unece:uncefact:data:specification:UnqualifiedDataTypesSchemaModule:2"
    xmlns:ccts="urn:un:unece:uncefact:documentation:2"
    xmlns:ext="urn:oasis:names:specification:ubl:schema:xsd:CommonExtensionComponents-2"
    xmlns:qdt="urn:oasis:names:specification:ubl:schema:xsd:QualifiedDatatypes-2"
    xmlns:ubltr="urn:oasis:names:specification:ubl:schema:xsd:TurkishCustomizationExtensionComponents"
    xmlns:ds="http://www.w3.org/2000/09/xmldsig#"          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2 UBL-Invoice-2.1.xsd"
    xmlns:xades="http://uri.etsi.org/01903/v1.3.2#" xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
    <ext:UBLExtensions>
        <ext:UBLExtension>
            <ext:ExtensionContent/>
        </ext:UBLExtension>
    </ext:UBLExtensions>
    <cbc:UBLVersionID>2.1</cbc:UBLVersionID>
    <cbc:CustomizationID>TR1.2</cbc:CustomizationID>
    <cbc:ProfileID>TICARIFATURA</cbc:ProfileID>
    <cbc:ID/>
    <cbc:CopyIndicator>false</cbc:CopyIndicator>
    <cbc:UUID>104E99B1-C11A-4447-8193-5BD40C384C2D</cbc:UUID>
    <cbc:IssueDate>2018-09-14</cbc:IssueDate>
    <cbc:InvoiceTypeCode>SATIS</cbc:InvoiceTypeCode>
    <cbc:Note>Sicil No: 33333, İşletme Merkezi: İstanbul</cbc:Note>
    <cbc:DocumentCurrencyCode>USD</cbc:DocumentCurrencyCode>
    <cbc:AccountingCost/>
    <cbc:LineCountNumeric>1</cbc:LineCountNumeric>

    <cac:Signature>
        <cbc:ID schemeID="VKN_TCKN">0201830512</cbc:ID>
        <cac:SignatoryParty>
            <cac:PartyIdentification>
                <cbc:ID schemeID="VKN">0201830512</cbc:ID>
            </cac:PartyIdentification>
            <cac:PostalAddress>
                <cbc:CitySubdivisionName>Mecidiyeköy</cbc:CitySubdivisionName>
                <cbc:CityName>İSTANBUL</cbc:CityName>
                <cac:Country>
                    <cbc:Name>TÜRKİYE</cbc:Name>
                </cac:Country>
            </cac:PostalAddress>
        </cac:SignatoryParty>
        <cac:DigitalSignatureAttachment>
            <cac:ExternalReference>
                <cbc:URI>#Signature_AAA2018000000015</cbc:URI>
            </cac:ExternalReference>
        </cac:DigitalSignatureAttachment>
    </cac:Signature>
    <cac:AccountingSupplierParty>
        <cac:Party>
            <cac:PartyIdentification>
                <cbc:ID schemeID="VKN">0201830512</cbc:ID>
            </cac:PartyIdentification>
            <cac:PartyName>
                <cbc:Name>Rota 8043</cbc:Name>
            </cac:PartyName>
            <cac:PostalAddress>
                <cbc:CitySubdivisionName>Mecidiyeköy</cbc:CitySubdivisionName>
                <cbc:CityName>İSTANBUL</cbc:CityName>
                <cac:Country>
                    <cbc:Name>TÜRKİYE</cbc:Name>
                </cac:Country>
            </cac:PostalAddress>
            <cac:PartyTaxScheme>
                <cac:TaxScheme>
                    <cbc:Name>SARIYER</cbc:Name>
                </cac:TaxScheme>
            </cac:PartyTaxScheme>
            <cac:Contact>
                <cbc:ElectronicMail>bahar.durmus@efinans.com.tr</cbc:ElectronicMail>
            </cac:Contact>
        </cac:Party>
    </cac:AccountingSupplierParty>
    <cac:AccountingCustomerParty>
        <cac:Party>
            <cac:PartyIdentification>
                <cbc:ID schemeID="VKN">1201830512</cbc:ID>
            </cac:PartyIdentification>
            <cac:PartyName>
                <cbc:Name>Rota 8443</cbc:Name>
            </cac:PartyName>
            <cac:PostalAddress>
                <cbc:CitySubdivisionName>test</cbc:CitySubdivisionName>
                <cbc:CityName>tes</cbc:CityName>
                <cac:Country>
                    <cbc:Name>AVUSTRALYA OKYANUSU</cbc:Name>
                </cac:Country>
            </cac:PostalAddress>
            <cac:PartyTaxScheme>
                <cac:TaxScheme>
                    <cbc:Name>test</cbc:Name>
                </cac:TaxScheme>
            </cac:PartyTaxScheme>
        </cac:Party>
    </cac:AccountingCustomerParty>
    <cac:PaymentMeans>
        <cbc:PaymentMeansCode>20</cbc:PaymentMeansCode>
        <cbc:PaymentDueDate>2018-09-14</cbc:PaymentDueDate>
        <cbc:PaymentChannelCode>Kasa</cbc:PaymentChannelCode>
        <cbc:InstructionNote>test</cbc:InstructionNote>
        <cac:PayeeFinancialAccount>
            <cbc:ID>123</cbc:ID>
            <cbc:CurrencyCode>USD</cbc:CurrencyCode>
        </cac:PayeeFinancialAccount>
    </cac:PaymentMeans>
    <cac:AllowanceCharge>
        <cbc:ChargeIndicator>false</cbc:ChargeIndicator>
        <cbc:Amount currencyID="USD">1.00</cbc:Amount>
    </cac:AllowanceCharge>
    <cac:PricingExchangeRate>
        <cbc:SourceCurrencyCode>USD</cbc:SourceCurrencyCode>
        <cbc:TargetCurrencyCode>TRY</cbc:TargetCurrencyCode>
        <cbc:CalculationRate>5</cbc:CalculationRate>
    </cac:PricingExchangeRate>
    <cac:TaxTotal>
        <cbc:TaxAmount currencyID="USD">1.62</cbc:TaxAmount>
        <cac:TaxSubtotal>
            <cbc:TaxableAmount currencyID="USD">9.00</cbc:TaxableAmount>
            <cbc:TaxAmount currencyID="USD">1.62</cbc:TaxAmount>
            <cbc:Percent>18</cbc:Percent>
            <cac:TaxCategory>
                <cac:TaxScheme>
                    <cbc:Name>KDV</cbc:Name>
                    <cbc:TaxTypeCode>0015</cbc:TaxTypeCode>
                </cac:TaxScheme>
            </cac:TaxCategory>
        </cac:TaxSubtotal>
    </cac:TaxTotal>
    <cac:LegalMonetaryTotal>
        <cbc:LineExtensionAmount currencyID="USD">10.00</cbc:LineExtensionAmount>
        <cbc:TaxExclusiveAmount currencyID="USD">9.00</cbc:TaxExclusiveAmount>
        <cbc:TaxInclusiveAmount currencyID="USD">10.62</cbc:TaxInclusiveAmount>
        <cbc:AllowanceTotalAmount currencyID="USD">1.00</cbc:AllowanceTotalAmount>
        <cbc:ChargeTotalAmount currencyID="USD">0.00</cbc:ChargeTotalAmount>
        <cbc:PayableRoundingAmount currencyID="USD">0</cbc:PayableRoundingAmount>
        <cbc:PayableAmount currencyID="USD">10.62</cbc:PayableAmount>
    </cac:LegalMonetaryTotal>
    <cac:InvoiceLine>
        <cbc:ID>1</cbc:ID>
        <cbc:InvoicedQuantity unitCode="C62">10</cbc:InvoicedQuantity>
        <cbc:LineExtensionAmount currencyID="USD">9.00</cbc:LineExtensionAmount>
        <cac:AllowanceCharge>
            <cbc:ChargeIndicator>false</cbc:ChargeIndicator>
            <cbc:MultiplierFactorNumeric>0.1</cbc:MultiplierFactorNumeric>
            <cbc:SequenceNumeric>0</cbc:SequenceNumeric>
            <cbc:Amount currencyID="USD">1.00</cbc:Amount>
            <cbc:BaseAmount currencyID="USD">10.00</cbc:BaseAmount>
        </cac:AllowanceCharge>
        <cac:TaxTotal>
            <cbc:TaxAmount currencyID="USD">1.62</cbc:TaxAmount>
            <cac:TaxSubtotal>
                <cbc:TaxableAmount currencyID="USD">9.00</cbc:TaxableAmount>
                <cbc:TaxAmount currencyID="USD">1.62</cbc:TaxAmount>
                <cbc:Percent>18</cbc:Percent>
                <cac:TaxCategory>
                    <cac:TaxScheme>
                        <cbc:Name>KDV</cbc:Name>
                        <cbc:TaxTypeCode>0015</cbc:TaxTypeCode>
                    </cac:TaxScheme>
                </cac:TaxCategory>
            </cac:TaxSubtotal>
        </cac:TaxTotal>
        <cac:Item>
            <cbc:Name>1</cbc:Name>
            <cac:SellersItemIdentification>
                <cbc:ID>1</cbc:ID>
            </cac:SellersItemIdentification>
        </cac:Item>
        <cac:Price>
            <cbc:PriceAmount currencyID="USD">1</cbc:PriceAmount>
        </cac:Price>
    </cac:InvoiceLine>
</Invoice>
'
DECLARE #binaryData VARBINARY(MAX)=(SELECT CAST(N'' AS XML).value('xs:base64Binary(sql:column("BASE64_COLUMN"))', 'VARBINARY(MAX)') FROM (SELECT #sendData AS BASE64_COLUMN) x)
--SELECT CONVERT(XML,CONVERT(VARCHAR(MAX),#binaryData))
SELECT CONVERT(CHAR(32),HashBytes('MD5',#binaryData),2) as 'hashCode'

SHA1 encryption trouble

I have a problem with the password encryption.
I would like to have the password encrypted like those not highlighted in the picture.
I wrote the following c# code:
SHA1CryptoServiceProvider x = new SHA1CryptoServiceProvider();
//byte[] bs = System.Text.Encoding.Unicode.GetBytes(password);
//byte[] bs = System.Text.Encoding.UTF32.GetBytes(password);
byte[] bs = System.Text.Encoding.UTF8.GetBytes(password);
bs = x.ComputeHash(bs);
var s = new StringBuilder();
foreach (byte b in bs)
{
s.Append(b.ToString("x2").ToLower());
}
new UserService().ChangeUserPassword(username, s.ToString());
to encrypt the password in the correct way I using the following SQL code that I want remove:
CAST(hashbytes('SHA1',#newuserpassword) as nvarchar)
this is the result:

Looking at the docs for CONVERT, I suspect you just want:
CONVERT(nvarchar, hashbytes('SHA1',#newuserpassword), 2)
Where 2 is the style which converts to hex without a leading 0x. I suggest you specify the length of the nvarchar though, which should be 40 (20 bytes, 2 characters per byte).

I strongly advise you to abandon storing binary data in characters. Still, if you need to keep it for legacy reasons, here is the translation of the SQL statement:
byte[] bytes = ...; //your binary data here
var nastilyBrokenChars =
Enumerable.Range(0, bytes.Length / 2)
.Select(i => (char)BitConverter.GetInt16(bytes, i * 2))
.ToArray();
string nastilyBrokenString = new string(nastilyBrokenChars);
As you can, I'm stuffing two bytes into each char. This by itself is a lossless conversion. But I wouldn't trust that storing this data into SQL Server (and comparing it later) is loss-less.

Getting different encryption results between C#.Net and Oracle

I want to encrypt some strings based on SHA1 algorithm in both C#.Net and Oracle 10g.
My algorithm in C#.Net:
string salt = "123";
System.Security.Cryptography.SHA1 sha = System.Security.Cryptography.SHA1.Create();
byte[] preHash = System.Text.Encoding.UTF32.GetBytes(salt);
byte[] hash = sha.ComputeHash(preHash);
string password = System.Convert.ToBase64String(hash);
password = password.Substring(0, 8);
// password value is: "7yP7/lkJ"
In Oracle:
Create Or Replace Function Sha1(P_Value Varchar2,P_Length Number) Return Varchar2
Is
P_String Varchar2(2000) := P_Value ;
L_Hash_Value_Raw Raw (100);
Lv_Hash_Value_Varchar Varchar2 (40);
Begin
L_Hash_Value_Raw := Dbms_Crypto.Hash (Src => Utl_Raw.Cast_To_Raw(P_String),
Typ => Dbms_Crypto.Hash_Sh1);
-- Convert Into Varchar2
Select Utl_Raw.Cast_To_Varchar2(Utl_Encode.Base64_Encode(L_Hash_Value_Raw))
Into Lv_Hash_Value_Varchar
From Dual;
Lv_Hash_Value_Varchar := Substr(Lv_Hash_Value_Varchar,0,P_Length);
Return Lv_Hash_Value_Varchar;
End;
Oracle's invokation:
select SHA1('123', 8) from dual; -- Result: "QLOAFWMI"
Maybe my general question is what is the difference between Oracle (PL/SQL) and .Net regarding encryption/raw/hex levels? I guess that answer would solve this specific problem.

you use wrong encoding. try the following code:
string salt = "123";
System.Security.Cryptography.SHA1 sha = System.Security.Cryptography.SHA1.Create();
byte[] preHash = System.Text.Encoding.UTF8.GetBytes(salt);
byte[] hash = sha.ComputeHash(preHash);
string password = System.Convert.ToBase64String(hash);
password = password.Substring(0, 8);

Categories

Resources