ma1 pushed to branch tor-browser-115.20.0esr-13.5-1 at The Tor Project / Applications / Tor Browser

Commits:

4 changed files:

Changes:

  • netwerk/dns/nsHostRecord.cpp
    ... ... @@ -39,6 +39,15 @@ nsHostKey::nsHostKey(const nsACString& aHost, const nsACString& aTrrServer,
    39 39 
           pb(aPb),
    40 40 
           originSuffix(aOriginsuffix) {}
    41 41
    42 
    +nsHostKey::nsHostKey(const nsHostKey& other)
    43 
    +    : host(other.host),
    44 
    +      mTrrServer(other.mTrrServer),
    45 
    +      type(other.type),
    46 
    +      flags(other.flags),
    47 
    +      af(other.af),
    48 
    +      pb(other.pb),
    49 
    +      originSuffix(other.originSuffix) {}
    50 
    +
    42 51 
     bool nsHostKey::operator==(const nsHostKey& other) const {
    43 52 
       return host == other.host && mTrrServer == other.mTrrServer &&
    44 53 
              type == other.type &&

  • netwerk/dns/nsHostRecord.h
    ... ... @@ -79,13 +79,15 @@ struct nsHostKey {
    79 79 
       const nsCString host;
    80 80 
       const nsCString mTrrServer;
    81 81 
       uint16_t type = 0;
    82 
    -  nsIDNSService::DNSFlags flags = nsIDNSService::RESOLVE_DEFAULT_FLAGS;
    82 
    +  mozilla::Atomic<nsIDNSService::DNSFlags> flags{
    83 
    +      nsIDNSService::RESOLVE_DEFAULT_FLAGS};
    83 84 
       uint16_t af = 0;
    84 85 
       bool pb = false;
    85 86 
       const nsCString originSuffix;
    86 87 
       explicit nsHostKey(const nsACString& host, const nsACString& aTrrServer,
    87 88 
                          uint16_t type, nsIDNSService::DNSFlags flags, uint16_t af,
    88 89 
                          bool pb, const nsACString& originSuffix);
    90 
    +  explicit nsHostKey(const nsHostKey& other);
    89 91 
       bool operator==(const nsHostKey& other) const;
    90 92 
       size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
    91 93 
       PLDHashNumber Hash() const;

  • netwerk/dns/nsHostResolver.cpp
    ... ... @@ -1116,7 +1116,8 @@ nsresult nsHostResolver::NameLookup(nsHostRecord* rec,
    1116 1116 
       }
    1117 1117
    1118 1118 
       LOG(("NameLookup: %s effectiveTRRmode: %d flags: %X", rec->host.get(),
    1119 
    -       static_cast<nsIRequest::TRRMode>(rec->mEffectiveTRRMode), rec->flags));
    1119 
    +       static_cast<nsIRequest::TRRMode>(rec->mEffectiveTRRMode),
    1120 
    +       static_cast<uint32_t>(rec->flags)));
    1120 1121
    1121 1122 
       if (rec->flags & nsIDNSService::RESOLVE_DISABLE_TRR) {
    1122 1123 
         rec->RecordReason(TRRSkippedReason::TRR_DISABLED_FLAG);
    ... ... @@ -1900,8 +1901,9 @@ void nsHostResolver::GetDNSCacheEntries(nsTArray<DNSCacheEntries>* args) {
    1900 1901 
         }
    1901 1902
    1902 1903 
         info.originAttributesSuffix = recordEntry.GetKey().originSuffix;
    1903 
    -    info.flags = nsPrintfCString("%u|0x%x|%u|%d|%s", rec->type, rec->flags,
    1904 
    -                                 rec->af, rec->pb, rec->mTrrServer.get());
    1904 
    +    info.flags = nsPrintfCString("%u|0x%x|%u|%d|%s", rec->type,
    1905 
    +                                 static_cast<uint32_t>(rec->flags), rec->af,
    1906 
    +                                 rec->pb, rec->mTrrServer.get());
    1905 1907
    1906 1908 
         args->AppendElement(std::move(info));
    1907 1909 
       }

  • security/manager/ssl/cert_storage/src/lib.rs
    ... ... @@ -40,6 +40,7 @@ use rkv::{StoreError, StoreOptions, Value};
    40 40 
     use rust_cascade::Cascade;
    41 41 
     use sha2::{Digest, Sha256};
    42 42 
     use std::collections::{HashMap, HashSet};
    43 
    +use std::convert::TryInto;
    43 44 
     use std::ffi::CString;
    44 45 
     use std::fmt::Display;
    45 46 
     use std::fs::{create_dir_all, remove_file, File, OpenOptions};
    ... ... @@ -266,10 +267,10 @@ impl SecurityState {
    266 267 
             };
    267 268 
             let reader = env_and_store.env.read()?;
    268 269 
             match env_and_store.store.get(&reader, key) {
    269 
    -            Ok(Some(Value::I64(i)))
    270 
    -                if i <= (std::i16::MAX as i64) && i >= (std::i16::MIN as i64) =>
    271 
    -            {
    272 
    -                Ok(Some(i as i16))
    270 
    +            Ok(Some(Value::I64(i))) => {
    271 
    +                Ok(Some(i.try_into().map_err(|_| {
    272 
    +                    SecurityStateError::from("Stored value out of range for i16")
    273 
    +                })?))
    273 274 
                 }
    274 275 
                 Ok(None) => Ok(None),
    275 276 
                 Ok(_) => Err(SecurityStateError::from(
    ... ... @@ -893,10 +894,10 @@ struct Cert<'a> {
    893 894
    894 895 
     impl<'a> Cert<'a> {
    895 896 
         fn new(der: &'a [u8], subject: &'a [u8], trust: i16) -> Result<Cert<'a>, SecurityStateError> {
    896 
    -        if der.len() > u16::max as usize {
    897 
    +        if der.len() > u16::MAX.into() {
    897 898 
                 return Err(SecurityStateError::from("certificate is too long"));
    898 899 
             }
    899 
    -        if subject.len() > u16::max as usize {
    900 
    +        if subject.len() > u16::MAX.into() {
    900 901 
                 return Err(SecurityStateError::from("subject is too long"));
    901 902 
             }
    902 903 
             Ok(Cert {
    ... ... @@ -920,7 +921,7 @@ impl<'a> Cert<'a> {
    920 921 
                 return Err(SecurityStateError::from("invalid Cert: no der len?"));
    921 922 
             }
    922 923 
             let (mut der_len, rest) = rest.split_at(size_of::<u16>());
    923 
    -        let der_len = der_len.read_u16::<NetworkEndian>()? as usize;
    924 
    +        let der_len = der_len.read_u16::<NetworkEndian>()?.into();
    924 925 
             if rest.len() < der_len {
    925 926 
                 return Err(SecurityStateError::from("invalid Cert: no der?"));
    926 927 
             }
    ... ... @@ -930,7 +931,7 @@ impl<'a> Cert<'a> {
    930 931 
                 return Err(SecurityStateError::from("invalid Cert: no subject len?"));
    931 932 
             }
    932 933 
             let (mut subject_len, rest) = rest.split_at(size_of::<u16>());
    933 
    -        let subject_len = subject_len.read_u16::<NetworkEndian>()? as usize;
    934 
    +        let subject_len = subject_len.read_u16::<NetworkEndian>()?.into();
    934 935 
             if rest.len() < subject_len {
    935 936 
                 return Err(SecurityStateError::from("invalid Cert: no subject?"));
    936 937 
             }
    ... ... @@ -961,15 +962,19 @@ impl<'a> Cert<'a> {
    961 962 
                     + size_of::<i16>(),
    962 963 
             );
    963 964 
             bytes.write_u8(CERT_SERIALIZATION_VERSION_1)?;
    964 
    -        if self.der.len() > u16::max as usize {
    965 
    -            return Err(SecurityStateError::from("certificate is too long"));
    966 
    -        }
    967 
    -        bytes.write_u16::<NetworkEndian>(self.der.len() as u16)?;
    965 
    +        bytes.write_u16::<NetworkEndian>(
    966 
    +            self.der
    967 
    +                .len()
    968 
    +                .try_into()
    969 
    +                .map_err(|_| SecurityStateError::from("certificate is too long"))?,
    970 
    +        )?;
    968 971 
             bytes.extend_from_slice(&self.der);
    969 
    -        if self.subject.len() > u16::max as usize {
    970 
    -            return Err(SecurityStateError::from("subject is too long"));
    971 
    -        }
    972 
    -        bytes.write_u16::<NetworkEndian>(self.subject.len() as u16)?;
    972 
    +        bytes.write_u16::<NetworkEndian>(
    973 
    +            self.subject
    974 
    +                .len()
    975 
    +                .try_into()
    976 
    +                .map_err(|_| SecurityStateError::from("subject is too long"))?,
    977 
    +        )?;
    973 978 
             bytes.extend_from_slice(&self.subject);
    974 979 
             bytes.write_i16::<NetworkEndian>(self.trust)?;
    975 980 
             Ok(bytes)
    ... ... @@ -1183,7 +1188,7 @@ fn load_crlite_stash_from_reader_into_map(
    1183 1188 
             let issuer_spki_hash_len = reader.read_u8().map_err(|e| {
    1184 1189 
                 SecurityStateError::from(format!("error reading stash issuer_spki_hash_len: {}", e))
    1185 1190 
             })?;
    1186 
    -        let mut issuer_spki_hash = vec![0; issuer_spki_hash_len as usize];
    1191 
    +        let mut issuer_spki_hash = vec![0; issuer_spki_hash_len.into()];
    1187 1192 
             reader.read_exact(&mut issuer_spki_hash).map_err(|e| {
    1188 1193 
                 SecurityStateError::from(format!("error reading stash issuer_spki_hash: {}", e))
    1189 1194 
             })?;
    ... ... @@ -1192,7 +1197,7 @@ fn load_crlite_stash_from_reader_into_map(
    1192 1197 
                 let serial_len = reader.read_u8().map_err(|e| {
    1193 1198 
                     SecurityStateError::from(format!("error reading stash serial_len: {}", e))
    1194 1199 
                 })?;
    1195 
    -            let mut serial = vec![0; serial_len as usize];
    1200 
    +            let mut serial = vec![0; serial_len.into()];
    1196 1201 
                 reader.read_exact(&mut serial).map_err(|e| {
    1197 1202 
                     SecurityStateError::from(format!("error reading stash serial: {}", e))
    1198 1203 
                 })?;

    • —
    View it on GitLab.
    You're receiving this email because of your account on gitlab.torproject.org. Manage all notifications · Help