For the primary signature it is "rsaEncryption" (OID 1.2.840.113549.1.1.1) and for the 
counter signature it is "RSA-SHA1" (OID 1.2.840.113549.1.1.5).

Thanks.
-Prasad


On Sep 22, 2014, at 09:13 AM, Jakob Bohm <jb-open...@wisemo.com> wrote:

Ok, look in the SignerInfo structure of the secondary signature.
There is a separate field (digestEncryptionAlgorithm) indicating
the OID of the signature algorithm. Look at this and see if it is
different from the value in the outer signature, and look up the
value online to see what it means.

On 22/09/2014 10:24, Prasad Dabak wrote:
       > Well, I am bit confused here.
       >
       > I am decrypting the signature using RSA_public_decrypt function
       > passing it a public key with RSA_PKCS1_PADDING option.
       >
       > For primary signature, I get back a 35 byte value which is inclusive
       > of the digestAlgorithm. It is in the v1.5format that you mention about.
       > For secondary signature, I get back a 20 byte value which matches
       > byte-to-byte with the digest (SHA1 hash of the signed attributes
       > si-        >auth_attr). But it doesn't include digestAlgorithm.
       >
       > I understand that primary and secondary signatures are generated by
       > different computers belonging to different companies. However, the
       > fact that the decrypted signature matches with the SHA1 hash of the
       > signed attributes makes me believe, that it's probably not a different
       > algorithm (DSS/DSA and ECDSA) issue and it doesn't look like "PSS"
       > format issue either.
       >
       > Thanks.
       > -Prasad
       >
       >
       > On Sep 19, 2014, at 10:24 AM, Jakob Bohm <jb-open...@wisemo.com  > 
wrote:
       >
       >        > On 19/09/2014 09:14, Prasad Dabak wrote:
       >        >        > The RFC links helped.
       >        >        >
       >        >        > I am able to do decrypt the encrypted digest and 
match it
       >        > with the
       >        >        > DigestInfo as explained in rfc2315.
       >        >        > DigestInfo ::= SEQUENCE {
       >        >        > digestAlgorithm DigestAlgorithmIdentifier,
       >        >        > digest Digest }
       >        >        >
       >        >        > Digest ::= OCTET STRING
       >        >        >
       >        >        > I typically get back 35 byte decrypted digest which 
matches
       >        > with sequence above.
       >        >        > I am also able to validate counterSignatures in 
similar fashion.
       >        >        >
       >        >        > Now I am trying this with various Authenticode 
executables
       >        > and one
       >        >        > small issue that I found is: For some authenticode
       >        > executables, the
       >        >        > counterSignature encryption only considers the bytes 
of the
       >        > Digest
       >        >        > OCTET_STRING i.e. it does not consider 
digestAlgorithm
       >        > field. Because
       >        >        > of this, the decrypted counterSignature is 20 bytes 
long
       >        > (size of sha1
       >        >        > hash) instead of 35 bytes mentioned earlier. It does 
match
       >        > with bytes
       >        >        > of the Digest OCTET_STRING.
       >        >        >
       >        >        > Is this expected behavior? How do I programmatically 
check this
       >        >        > behavior? If the size of decrypted counterSignature 
is equal
       >        > to size
       >        >        > of the hash, assume that digestAlgorithm field is not
       >        > considered?
       >        >        >
       >        > "Decrypting" and RSA signature should produce a byte string 
almost
       >        > as long as the RSA key length, e.g.127 bytes for 1024 bits, 
255
       >        > bytes for 2048 bits etc.
       >        >
       >        > Next step is to check if those 127/255/... bytes are formatted
       >        > according to the appropriate portion of PKCS#1, whichspecifies
       >        > TWO different formats, the old "v1.5" format which is mostly 
the
       >        > DigestAlgorithm OID and the digest packed into a simple ASN.1
       >        > structure and then padded, and the new "PSS" format, where the
       >        > hash is combined with a random value using a formula which you
       >        > can only reverse if you know what the digest should be.
       >        >
       >        > I suspect you may be encountering both formats, since the
       >        > countersignature and the primary signature are generated by
       >        > different computers belonging to different companies (the
       >        > countersignature is generated by a server owned and run be 
the CA,
       >        > the primary signature is generated by the manufacturer and/or
       >        > Symantec).
       >        >
       >        > You also need to consider that other signature algorithms 
such as
       >        > DSS/DSA and ECDSA might be used, as specified in the 
certificates
       >        > used for the signatures.
       >        >
       >        > Note: For RSA signatures, PKCS#1 == RFC3447.
       >        >
       >        >        > Thanks.
       >        >        > -Prasad
       >        >        >
       >        >        >
       >        >        > On Sep 16, 2014, at 10:51 AM, Jakob Bohm
       >        > <jb-open...@wisemo.com <mailto:jb-open...@wisemo.com  >        
> wrote:
       >        >        >
       >        >        >        > On 16/09/2014 12:22, Prasad Dabak wrote:
       >        >        >        >        > Hello,
       >        >        >        >        >
       >        >        >        >        > I am currently focusing on matching
       >        > various digests that we
       >        >        >        > talked
       >        >        >        >        > about earlier in the thread.
       >        >        >        >        >
       >        >        >        >        > 1. Computing the hash of the 
executable
       >        > (excluding the areas as
       >        >        >        >        > defined by MS) and matching it 
with the
       >        > value stored in
       >        >        >        >        > spcIndirectData. This is straight 
forward
       >        > and figured out.
       >        >        >        >        > 2. Computing the hash of 
spcIndirectData
       >        > and matching it
       >        >        >        > with with
       >        >        >        >        > "messageDigest" stored in
       >        > AuthenticatedAttributes. I
       >        >        >        > realized that the
       >        >        >        >        > sequence and length bytes need to 
be
       >        > skipped before
       >        >        >        > computing the hash
       >        >        >        >        > of the spcIndirectData? Is this 
documented
       >        > anywhere?
       >        >        >        > This is specified in the PKCS#7 standard 
(RFC2315),
       >        > in particular,
       >        >        >        > PKCS#7 specifies that when there is a 
non-empty
       >        > contentInfo field
       >        >        >        > in the PKCS#7 structure, which part of that 
should
       >        > be hashed. In
       >        >        >        > this case that contentInfo is a 
Microsoft-defiend
       >        > spcIndirectData,
       >        >        >        > but the calculation is unaffected. This 
should also
       >        > be built in
       >        >        >        > to the PKCS7 functions (I hope).
       >        >        >        >        > 3. Computing hash of
       >        > AuthenticatedAttributes and matching it
       >        >        >        > with
       >        >        >        >        > decrypted version of 
encryptedDigest. I am
       >        > struggling to get
       >        >        >        > this.
       >        >        >        >        > Which portion of 
AuthenticatedAttributes
       >        > should be
       >        >        >        > considered for
       >        >        >        >        > computing the hash? Further when I 
decrypt
       >        > the
       >        >        >        > encryptedDigest using
       >        >        >        >        > the signer's public key, I get 
back a 256
       >        > byte value. This
       >        >        >        > doesn't
       >        >        >        >        > look like a SHA1 hash like in case 
(1) and
       >        > (2). So what type
       >        >        >        > of hash
       >        >        >        >        > it is? Can someone elaborate OR 
point to
       >        > documentation that
       >        >        >        > elaborates
       >        >        >        >        > on this?
       >        >        >        > This is specified in the PKCS#7 standard 
(RFC2315).
       >        > This should
       >        >        >        > also be built in to the PKCS7 functions (I 
hope).
       >        >        >        >
       >        >        >        > By the way, the rules for checking the 
timestamp
       >        > countersignature
       >        >        >        > (but not its effect on checking the outer
       >        > signature) is specified
       >        >        >        > in RFC2985 section 5.3.6. The rules for 
parsing the
       >        > SigningTime
       >        >        >        > attribute used inside timestamp 
contersignatures
       >        > (and elsewhere
       >        >        >        > with less trust) are in RFC2985 section 
5.3.3.
       >        >        >        >        >
       >        >        >        >        > On Sep 09, 2014, at 10:18 AM, 
Prasad Dabak
       >        >        >        > <pda...@icloud.com <mailto:pda...@icloud.com  
>
       >        > <mailto:pda...@icloud.com <mailto:pda...@icloud.com    >    >    
    > wrote:
       >        >        >        >        >
       >        >        >        >        >        > Thanks Jacob for your 
response.
       >        > Very informative
       >        >        >        > indeed!
       >        >        >        >        >        >
       >        >        >        >        >        > Thanks
       >        >        >        >        >        > -Prasad
       >        >        >        >        >        >
       >        >        >        >        >        > Sent from my iPhone
       >        >        >        >        >        >
       >        >        >        >        >        >        > On 09-Sep-2014, 
at 10:05 pm,
       >        > Jakob Bohm
       >        >        >        >        >        > <jb-open...@wisemo.com
       >        > <mailto:jb-open...@wisemo.com      >
       >        >        >        > <mailto:jb-open...@wisemo.com
       >        > <mailto:jb-open...@wisemo.com      >        > 
<mailto:jb-open...@wisemo.com
       >        > <mailto:jb-open...@wisemo.com      >
       >        >        >        > <mailto:jb-open...@wisemo.com
       >        > <mailto:jb-open...@wisemo.com      >        >        >        
> wrote:
       >        >        >        >        >        >        >
       >        >        >        >        >        >        >        > On 
09/09/2014
       >        > 09:01, Prasad Dabak
       >        >        >        > wrote:
       >        >        >        >        >        >        >        > Thanks 
Jacob for an
       >        > elaborate
       >        >        >        > answer. Somehow I
       >        >        >        >        >        > never received your 
response to
       >        > my registered email
       >        >        >        > address, hence
       >        >        >        >        >        > delay in responding.
       >        >        >        >        >        >        > This time I have 
CC-ed you
       >        > in addition to
       >        >        >        > the mail list.
       >        >        >        >        >        >        >        > I have 
a few
       >        > follow-up questions
       >        >        >        > on your response.
       >        >        >        >        >        >        >        >
       >        >        >        >        >        >        >        > 1. So,
       >        > "encryptedDigest" has no
       >        >        >        > relation to the
       >        >        >        >        >        > stored "messageDigest"? I 
thought
       >        > it's a encrypted
       >        >        >        > version of the
       >        >        >        >        >        > messageDigest?
       >        >        >        >        >        >        > As far as I 
recall, there is
       >        > a chain of 4
       >        >        >        > digests. The first
       >        >        >        >        >        > digest
       >        >        >        >        >        >        > is calculated 
over the file
       >        > and is stored
       >        >        >        > in the
       >        >        >        >        >        > spcIndirectData. The
       >        >        >        >        >        >        > second digest is 
calculated
       >        > over the
       >        >        >        > spcIndirectData (the
       >        >        >        >        >        > contentInfo
       >        >        >        >        >        >        > of the the 
PKCS#7 structure)
       >        > and is stored as
       >        >        >        >        >        > "messageDigest" in the
       >        >        >        >        >        >        > 
AuthenticatedAttributes of
       >        > each PKCS#7
       >        >        >        > signerInfo. The third
       >        >        >        >        >        > hash
       >        >        >        >        >        >        > is calculated 
over the
       >        >        >        > AuthenticatedAttributes and is signed to
       >        >        >        >        >        >        > produce the
       >        > "encryptedDigest" in that same
       >        >        >        > signerInfo. All 3
       >        >        >        >        >        > need to
       >        >        >        >        >        >        > be checked to 
confirm that
       >        > the file hash
       >        >        >        > is actually
       >        >        >        >        >        > (indirectly)
       >        >        >        >        >        >        > signed by the
       >        > encryptedDigest using the
       >        >        >        > public key in the
       >        >        >        >        >        > certificate
       >        >        >        >        >        >        > whose name is 
listed in the
       >        > signerInfo.
       >        >        >        >        >        >        >        > 2. I 
agree that
       >        > it's better to do
       >        >        >        > cheaper checks
       >        >        >        >        >        > first e.g. I am also 
matching PE
       >        > checksum stored in
       >        >        >        > the optional header.
       >        >        >        >        >        >        > Indeed, though 
that is a
       >        > very weak
       >        >        >        > checksum (file size plus
       >        >        >        >        >        > 16 bit TCP/IP
       >        >        >        >        >        >        > checksum of 
file). Also it
       >        > is allowed to
       >        >        >        > be 0 to indicate no
       >        >        >        >        >        > checksum
       >        >        >        >        >        >        > (even if you set 
the
       >        > checksum, it might be
       >        >        >        > cleared if an
       >        >        >        >        >        > Administrator
       >        >        >        >        >        >        > adds his own
       >        > countersignature to all
       >        >        >        > authorized programs on his
       >        >        >        >        >        >        > computers, aka 
AppLocker).
       >        >        >        >        >        >        >        > 3. 
spcPEImageData
       >        > is probably
       >        >        >        > relevant only for
       >        >        >        >        >        > signing that uses page 
hashes?
       >        >        >        >        >        >        > I never quite 
figured out
       >        > where they store
       >        >        >        > the page hashes.
       >        >        >        >        >        > However I
       >        >        >        >        >        >        > believe the 
constant semi-empty
       >        >        >        > spcPEImageData with the
       >        >        >        >        >        > "<<<obsolete    >        >    
>"
       >        >        >        >        >        >        > string is the 
traditional
       >        > marker to
       >        >        >        > indicate that the
       >        >        >        >        >        > signature is for
       >        >        >        >        >        >        > a PE file, and 
not e.g. a
       >        > document file
       >        >        >        > with the same hashed
       >        >        >        >        >        > bytestream.
       >        >        >        >        >        >        >
       >        >        >        >        >        >        >        > 4. 
PKCS7_verify is
       >        > already
       >        >        >        > matching the
       >        >        >        >        >        > encryptedDigest, do we 
still need
       >        > to validate it
       >        >        >        > ourselves?
       >        >        >        >        >        >        > If it is, I am 
myself
       >        > guessing a bit as to
       >        >        >        > what that
       >        >        >        >        >        > function does and
       >        >        >        >        >        >        > does not check. 
But note
       >        > that it probably
       >        >        >        > doesn't check the
       >        >        >        >        >        > full chain
       >        >        >        >        >        >        > of 3 message 
digests, since
       >        > at least the
       >        >        >        > digest over the
       >        >        >        >        >        > file itself is
       >        >        >        >        >        >        > inside a blob 
that the
       >        > PKCS#7 standard has
       >        >        >        > no opinion about.
       >        >        >        >        >        >        >        > 5. So, 
basically
       >        > are are
       >        >        >        > suggesting to look into
       >        >        >        >        >        > the subject string and 
see if we
       >        > can find patterns
       >        >        >        > like
       >        >        >        >        >        > /CN=COMPANY-NAME... 
issuer:
       >        >        >        > /C=US/O=SIGNER_NAME....? How
       >        >        >        >        >        > authoritative it is? I 
mean can
       >        > someone else have
       >        >        >        > same COMPANY-NAME
       >        >        >        >        >        > and PATTERN-NAME in their
       >        > certificate?
       >        >        >        >        >        >        > Actually, the 
subject is a
       >        > data structure
       >        >        >        > (a hierarchical
       >        >        >        >        >        > list of sets
       >        >        >        >        >        >        > of tagged 
strings) and the
       >        > relevant
       >        >        >        > comparison would be to
       >        >        >        >        >        > compare those
       >        >        >        >        >        >        > elements that 
don't change
       >        > when getting a
       >        >        >        > new certificate
       >        >        >        >        >        > from the CA.
       >        >        >        >        >        >        > It is the CAs 
responsibility
       >        > to make sure
       >        >        >        > the don't issue
       >        >        >        >        >        > certificates
       >        >        >        >        >        >        > to the wrong 
people, and if
       >        > they make a
       >        >        >        > mistake they are
       >        >        >        >        >        > expected to
       >        >        >        >        >        >        > quickly add the 
bad
       >        > certificate to their
       >        >        >        > published CRL,
       >        >        >        >        >        > which is why
       >        >        >        >        >        >        > you need to 
check the CRL
       >        > before trusting
       >        >        >        > the certificate. An
       >        >        >        >        >        >        > additional check 
is to make
       >        > sure the CA
       >        >        >        > that issued the
       >        >        >        >        >        > intermediary
       >        >        >        >        >        >        > certificate that 
issued the
       >        > "COMAPNY-NAME"
       >        >        >        > certificate is
       >        >        >        >        >        > actually one
       >        >        >        >        >        >        > of the (few) CAs 
that
       >        > "COMPANY-NAME" is
       >        >        >        > going to buy
       >        >        >        >        >        > certificates from.
       >        >        >        >        >        >        > This protects 
against fake
       >        > certificates
       >        >        >        > issued by smaller
       >        >        >        >        >        > CAs that
       >        >        >        >        >        >        > you aren't going 
to use anyway.
       >        >        >        >        >        >        >        >
       >        >        >        >        >        >        >        > In my 
case, I am
       >        > the one who is
       >        >        >        > signing the
       >        >        >        >        >        > executable using my 
certificate
       >        > and a "cross
       >        >        >        > certificate" issued by
       >        >        >        >        >        > Microsoft and I want to
       >        > programmatically ensure
       >        >        >        > following things.
       >        >        >        >        >        >        >        >
       >        >        >        >        >        >        >        > 1. Code 
is not
       >        > tampered since it
       >        >        >        > was signed
       >        >        >        >        >        > (matching messageDigest 
with
       >        > computed hash)
       >        >        >        >        >        >        > Actually 
matching digest in
       >        >        >        > spcIndirectData with computed
       >        >        >        >        >        > hash. Plus
       >        >        >        >        >        >        > consistency 
checks to make
       >        > sure the
       >        >        >        > signature is actually
       >        >        >        >        >        > for a PE file
       >        >        >        >        >        >        > and was not 
otherwise
       >        > doctored. For
       >        >        >        > instance there should be
       >        >        >        >        >        > no bytes
       >        >        >        >        >        >        > in the file 
after the end of
       >        > the signature
       >        >        >        > blob.
       >        >        >        >        >        >        >        > 2. 
Verifying the
       >        > digital
       >        >        >        > signature (PKCS7_Verify)
       >        >        >        >        >        >        >        > 3. 
Confirming that
       >        > the executable
       >        >        >        > is signed by my
       >        >        >        >        >        > company certificate.
       >        >        >        >        >        >        >        >
       >        >        >        >        >        >        >        > I am 
stuck on part
       >        > (3) and don't
       >        >        >        > see a clean way
       >        >        >        >        >        > apart from matching 
strings in
       >        > subject field? If I
       >        >        >        > hard-code the
       >        >        >        >        >        > public key in my 
verification
       >        > code, I will need to
       >        >        >        > update it when I
       >        >        >        >        >        > switch to a newer public 
key?
       >        >        >        >        >        >        > Yep, that is why 
careful
       >        > matching against
       >        >        >        > various
       >        >        >        >        >        > Distinguished Name
       >        >        >        >        >        >        > fields is needed.
       >        >        >        >        >        >        >
       >        >        >        >        >        >        >        >
       >        >        >        >        >        >        >        >        
> On Sep 06,
       >        > 2014, at 09:44
       >        >        >        > PM, Prasad Dabak
       >        >        >        >        >        > <pda...@icloud.com
       >        > <mailto:pda...@icloud.com      > <mailto:pda...@icloud.com
       >        > <mailto:pda...@icloud.com      >        >
       >        >        >        > <mailto:pda...@icloud.com
       >        > <mailto:pda...@icloud.com      > <mailto:pda...@icloud.com
       >        > <mailto:pda...@icloud.com      >    >        >        > wrote:
       >        >        >        >        >        >        >        >        >
       >        >        >        >        >        >        >        >        
> Hello,
       >        >        >        >        >        >        >        >        >
       >        >        >        >        >        >        >        >        
> Given a
       >        > signed Windows portable
       >        >        >        >        >        > executable, I want to
       >        > programmatically verify two
       >        >        >        > things using
       >        >        >        >        >        > openssl APIs
       >        >        >        >        >        >        >        >        >
       >        >        >        >        >        >        >        >        
> 1. Verify
       >        > the digital signature.
       >        >        >        >        >        >        >        >        
> 2. Confirm
       >        > that the
       >        >        >        > executable is signed
       >        >        >        >        >        > by a specific company 
using that
       >        > company's public key.
       >        >        >        >        >        >        >        >        >
       >        >        >        >        >        >        >        >        
> It seems
       >        > that part (1) can
       >        >        >        > be done by
       >        >        >        >        >        > parsing the signedData 
attribute
       >        > in the portable
       >        >        >        > executable,
       >        >        >        >        >        > extracting the hashing 
algorithm
       >        > and digest stored
       >        >        >        > there,
       >        >        >        >        >        > re-computing the digest 
of the
       >        > executable using the
       >        >        >        > same hashing
       >        >        >        >        >        > algorithm and match them.
       >        >        >        >        >        >        >        >        >
       >        >        >        >        >        >        >        >        
> I have
       >        > following questions.
       >        >        >        >        >        >        >        >        >
       >        >        >        >        >        >        >        >        
> 1. The
       >        > signData contains
       >        >        >        > messageDigest
       >        >        >        >        >        > (unencrypted) and 
encryptedDigest
       >        > (encrypted). Is
       >        >        >        > it enough to match
       >        >        >        >        >        > messgaeDigest with the 
computed
       >        > digest? OR we also
       >        >        >        > need to decrypt
       >        >        >        >        >        > the encryptedDigest using 
the
       >        > company public key
       >        >        >        > and match that as well?
       >        >        >        >        >        >        >        >        
> 2. What
       >        > does PKCS7_Verify
       >        >        >        > exactly do? I
       >        >        >        >        >        > looked at
       >        >        >        >
       >        > https://www.openssl.org/docs/crypto/PKCS7_verify.htmland I
       >        >        >        >        >        > understand that it 
verifies
       >        > certificate chain.
       >        >        >        > However, it's not
       >        >        >        >        >        > clear to me as to what 
exactly it
       >        > does with respect
       >        >        >        > to signature
       >        >        >        >        >        > verification?
       >        >        >        >        >        >        >        >        
> 3. I am
       >        > assuming that I
       >        >        >        > require to do both
       >        >        >        >        >        > (1) and (2) in order to 
verify
       >        > the authenticode
       >        >        >        > signature?
       >        >        >        >        >        >        >        >        
> 4. What is
       >        > the best way to
       >        >        >        > verify if the
       >        >        >        >        >        > executable is signed by 
specific
       >        > company using that
       >        >        >        > company's public key?
       >        >        >        >        >        >        >        >        >
       >        >        >        >        >        >        >        >        
> Any inputs
       >        > will be greatly
       >        >        >        > appreciated!
       >        >        >        >        >        >        >
       >        >        >        >


Enjoy

Jakob
--
Jakob Bohm, CIO, Partner, WiseMo A/S. http://www.wisemo.com
Transformervej 29, 2860 Søborg, Denmark. Direct +45 31 13 16 10
This public discussion message is non-binding and may contain errors.
WiseMo - Remote Service Management for PCs, Phones and Embedded

______________________________________________________________________
OpenSSL Project http://www.openssl.org
User Support Mailing List openssl-users@openssl.org
Automated List Manager majord...@openssl.org

Reply via email to