FERRAMENTAS LINUX: Atualização moderada de segurança do openSUSE para o rust, rust-cbindgen, aviso openSUSE: 2020:0945-1

terça-feira, 7 de julho de 2020

Atualização moderada de segurança do openSUSE para o rust, rust-cbindgen, aviso openSUSE: 2020:0945-1



Confira !!



Uma atualização que resolve uma vulnerabilidade e tem duas correções está agora disponível.
   Atualização de segurança do openSUSE: Atualização de segurança para rust, rust-cbindgen
______________________________________________________________________________

ID do anúncio: openSUSE-SU-2020: 0945-1
Classificação: moderado
Referências: # 1115645 # 1154817 # 1173202
Referências cruzadas: CVE-2020-1967
Produtos afetados:
                    openSUSE Leap 15.2
______________________________________________________________________________

   Uma atualização que resolve uma vulnerabilidade e tem duas correções
   está agora disponivel.

Descrição:

   Esta atualização para rust, rust-cbindgen corrige os seguintes problemas:

   rust foi atualizado para uso pelo Firefox 76ESR.

   - Correções de erros de compactação com rustc 1.43 que levam a falhas no LTO
     (bsc # 1173202)

   Atualize para a versão 1.43.1

   - Atualizado o openssl-src para 1.1.1g para CVE-2020-1967.
   - Corrigida a estabilização dos recursos do AVX-512.
   - Corrigido o `pacote de carga - lista` que não trabalha com dependências não publicadas.

   Atualize para a versão 1.43.0

   + Idioma:

   - Corrigido usando operações binárias com `& {number}` (por exemplo, `& 1.0`) não tendo
     o tipo inferido corretamente.
   - Atributos como `# [cfg ()]` agora podem ser usados ​​em expressões `if`.
   - Sintaxe apenas muda:
     * Permita `tipo Foo: Ord` sintaticamente.
     * Fusível itens associados e externos até o padrão.
     * Permitir sintaticamente o `self 'em todos os contextos` fn`.
     * Mesclar sintaxe `fn` + análise de item de limpeza.
     * fragmentos de macro `item` podem ser interpolados em` trait`s, `impl`s e
       Blocos externos. Por exemplo, agora você pode escrever: `` `rust macro_rules!
       mac_trait {($ i: item) => {característica T {$ i}}} mac_trait! {fn foo () {}
       } `` `
     * Eles ainda são rejeitados * semanticamente *, então você provavelmente receberá um
       erro, mas essas alterações podem ser vistas e analisadas por macros e
       compilação condicional.

   + Compilador

   - Agora você pode passar várias bandeiras de cotão para enferrujar para substituir as anteriores
     bandeiras.

     Por exemplo; `rustc -D não utilizado -Uma-variáveis ​​não utilizadas` nega tudo em
   o grupo de fios não utilizados, exceto as variáveis ​​não utilizadas, explicitamente
   permitido. Entretanto, passar `rustc -A unused-variable -D unused` nega
   tudo no grupo de fiapos 'não utilizado' ** incluindo ** `variáveis ​​não utilizadas`
   desde que o sinalizador de permissão seja especificado antes do sinalizador de negação (e, portanto,
     substituído).
   - rustc agora prefere as bibliotecas MinGW do seu sistema em vez dos pacotes
     bibliotecas, se estiverem disponíveis no `windows-gnu`.
   - rustc agora armazena em buffer erros / avisos impressos em JSON.

   Bibliotecas:

   - `Arco <[T; N]> `,` Caixa <[T; N]> `e` Rc <[T; N]> `, agora implemente
     `TryFrom> `,` TryFrom> `e` TryFrom> `
     respectivamente.
     ** Nota ** Essas conversões estão disponíveis apenas quando `N` é` 0 .. = 32`.
   - Agora você pode usar constantes associadas em números flutuantes e números inteiros diretamente,
     em vez de precisar importar o módulo. Agora você pode escrever
     `u32 :: MAX` ou` f32 :: NAN` sem importação.
   - `u8 :: is_ascii` agora é` const`.
   - `String` agora implementa` AsMut`.
   - Adicionado o módulo `primitivo` ao` std` e `core`. Este módulo reexporta
     Tipos primitivos de Rust. Isso é útil principalmente em macros onde você deseja
     evite que esses tipos sejam sombreados.
   - Relaxou algumas das características do `HashMap` e` HashSet`.
   - `string :: FromUtf8Error` agora implementa` Clone + Eq`.

   + APIs estabilizadas

   - `Once :: is_completed`
   - `f32 :: LOG10_2`
   - `f32 :: LOG2_10`
   - `f64 :: LOG10_2`
   - `f64 :: LOG2_10`
   - `iter :: once_with`

   + Carga

     - Agora você pode definir config `[profile]` s no seu `.cargo / config`,
       ou através do seu ambiente.
     - A carga agora definirá `CARGO_BIN_EXE_`apontando para um binário
       caminho executável ao executar testes de integração ou benchmarks. ``
       é o nome do seu binário como está, por exemplo, se você queria o executável
       caminho para um binário chamado `my-program` que você usaria
       `env! (" CARGO_BIN_EXE_my-program ")`.

   + Diversos

     - Determinadas verificações no fio `const_err` foram consideradas não relacionadas à const
       avaliação e foram movidos para o `unconditional_panic` e
       `arithmetic_overflow` fiapos.

   + Notas de compatibilidade

     - Ter sintaxe à direita na macro `assert!` Agora é um erro grave.
       Este é um aviso desde 1.36.0.
     - Corrigido 'Self' não tendo o tipo corretamente inferido. Isso incorretamente
       levou a que algumas instâncias fossem aceitas e agora emite corretamente
       erro.

   Atualize para a versão 1.42.0:

   + Idioma

     - Agora você pode usar a sintaxe do padrão de fatia com sub-fatias.
     - Agora você pode usar # [repr (transparente)] em enumerações univariantes. Significa que
       você pode criar uma enumeração que tenha o layout exato e a ABI do tipo
       contém.
     - Existem algumas alterações apenas de sintaxe:
       * o padrão é sintaticamente permitido antes dos itens nas definições de características.
       * Os itens em impls (ou seja, consts, tipos e fns) podem deixar sintaticamente
         seus corpos em favor de;
       * Limites nos tipos associados nos impls agora são permitidos sintaticamente
         (por exemplo, tipo Foo: Ord;).
       * ... (o tipo C-variadic) pode ocorrer sintaticamente diretamente como o
         tipo de qualquer parâmetro de função. Estes ainda são rejeitados
         semanticamente, então você provavelmente receberá um erro, mas essas alterações
         pode ser visto e analisado por macros processuais e condicionais
         compilação.

   + Compilador

     - Adicionado suporte de camada 2 para armv7a-none-eabi.
     - Adicionado suporte de camada 2 para riscv64gc-unknown-linux-gnu.
     - Opção :: {expect, desembrulhar} e Resultado :: {expect, expect_err, desembrulhar,
       unwrap_err} agora produzem mensagens de pânico apontando para o local onde
       eles foram chamados, em vez de internos do núcleo. Consulte Rust's
       página de suporte da plataforma para obter mais informações sobre a plataforma em camadas da Rust
       Apoio, suporte.

   + Bibliotecas

     - iter :: Vazio agora implementa Enviar e sincronizar para qualquer T.
     - Pin :: {map_unchecked, map_unchecked_mut} não exige mais o retorno
       digite para implementar Sized.
     - io :: Cursor agora deriva PartialEq e Eq.
     - Layout :: new agora é const.
     - Adicionado suporte à Biblioteca Padrão para riscv64gc-unknown-linux-gnu.

   + APIs estabilizadas

     - CondVar :: wait_ while
     - CondVar :: wait_timeout_ilst
     - DebugMap :: key
     - DebugMap :: value
     - ManuallyDrop :: take
     - partidas!
     - ptr :: slice_from_raw_parts_mut
     - ptr :: slice_from_raw_parts

   + Carga

     - Você não precisa mais incluir extern crate proc_macro; ser capaz de
       use proc_macro; na edição de 2018.

   + Notas de compatibilidade

     - Error :: description foi descontinuado e seu uso agora produzirá um
       Aviso. É recomendável usar Display / to_string.

   Atualize para a versão 1.41.1:

     - Sempre verifique os tipos de itens estáticos
     - Verifique sempre os limites da vida útil dos implos de `Copy`
     - Correção de compilação incorreta nos chamadores de `Layout :: repeat`

   Atualize para a versão 1.41.0:

   + Idioma

     - Agora você pode passar parâmetros de tipo para itens externos ao implementar
       traços. Agora você pode escrever `impl De para Vec {} `.
     - Agora você pode aninhar arbitrariamente os tipos de receptor na posição `self '.
       Por exemplo, agora você pode escrever `fn foo (self: Box>) {} `. Anteriormente
       apenas `Self`,` & Self`, `& mut Self`,` Arc`,` Rc`e
       `Caixa`foram permitidos.
     - Agora você pode usar qualquer identificador válido em uma macro `format_args`.
       Identificadores anteriores começando com um sublinhado não eram permitidos.
     - Modificadores de visibilidade (por exemplo, `pub`) agora são permitidos sintaticamente em
       itens de características e variantes de enumeração. Estes ainda são rejeitados semanticamente,
       mas pode ser visto e analisado por macros processuais e condicionais
       compilação.

   + Compilador

     - O Rustc avisará agora se você tiver um `` rótulo '' não utilizado.
     - Suporte removido para o alvo `i686-unknown-dragonfly`
     - Adicionado suporte de camada 3 \ * para o destino `riscv64gc-unknown-linux-gnu`.
     - Agora você pode passar um arquivo de argumentos passando a sintaxe `@ path` para
       rustc. Observe que o formato difere um pouco do encontrado em
       outras ferramentas; consulte a documentação para obter mais informações.
     - Agora você pode fornecer o sinalizador `--extern` sem um caminho, indicando que ele
       está disponível no caminho de pesquisa ou especificado com um sinalizador `-L`.

     Consulte a [página de suporte da plataforma] da Rust [forge-platform-support] para obter mais
   informações sobre o suporte de plataforma em camadas da Rust.

   + Bibliotecas

     - O módulo `core :: panic` agora está estável. Já era estável através
       `std`.
     - Números `NonZero *` agora implementam `From`se é um menor
       largura inteira. Por exemplo, `NonZeroU16` agora implementa` From`.
     - `TalvezUninitagora implementa `fmt :: Debug`.

   + APIs estabilizadas

     - `Resultado :: map_or`
     - `Resultado :: map_or_else`
     - `std :: rc :: Weak :: weak_count`
     - `std :: rc :: Weak :: strong_count`
     - `std :: sync :: Weak :: weak_count`
     - `std :: sync :: Weak :: strong_count`

   + Carga

     - Cargo agora documentará todos os itens particulares para caixas binárias
       padrão.
     - `cargo-install` agora reinstalará o pacote se detectar que
       está fora
       da data.
     - Cargo.lock agora usa um formato mais amigável ao git que deve ajudar a
       reduzir conflitos de mesclagem.
     - Agora você pode substituir as configurações de compilação de dependências específicas. Por exemplo
       `[profile.dev.package.image] opt-level = 2` define as caixas da` imagem`
       nível de otimização para `2` para compilações de depuração. Você também pode usar
        `[perfil..build-override] `para substituir scripts de construção e
        suas dependências.

   + Diversos

     - Agora você pode especificar `edition` nos blocos de código da documentação para compilar
       o bloco para essa edição. Por exemplo, `edition2018` diz ao rustdoc que o
       A amostra de código deve ser compilada na edição 2018 do Rust.
     - Agora você pode fornecer temas personalizados ao rustdoc com `--theme` e verificar
       o tema atual com `--check-theme`.
     - Você pode usar `# [cfg (doc)]` para compilar um item ao criar
       documentação.

   + Notas de compatibilidade

     - Como anunciado anteriormente, 1.41.0 será o último release de nível 1 para
       Destinos Apple de 32 bits. Isso significa que o código fonte ainda está
       disponíveis para construção, mas os destinos não estão mais sendo testados e
       binários de lançamento para essas plataformas não serão mais distribuídos por
       o projeto Rust. Consulte a postagem do blog vinculado para obter mais informações.
       em formação.

   - Versão Bump do libssh2 para o SLE15; agora precisamos de uma versão com
     libssh2_userauth_publickey_frommemory (), que apareceu na libssh2 1.6.0.

   Atualize para a versão 1.40.0

   + Idioma

     - Agora você pode usar as variantes da tupla `struct`s e da tupla` enum`
       construtores em contextos `const`. por exemplo, pub struct Point (i32, i32);
       const ORIGEM: Point = {construtor = Point; construtor (0, 0)};
     - Agora você pode marcar as variantes `struct`s,` enum`s e `enum` com o
       atributo `# [non_exhaustive]` para indicar que pode haver variantes
       ou campos adicionados no futuro. Por exemplo, isso requer a adição de um
       ramificação curinga (`_ => {}`) para qualquer declaração de correspondência em um
       enum não exaustivo.
     - Agora você pode usar macros procedurais semelhantes a funções em blocos externos e
       em posições de tipo. eg `tipo Gerado = macro! ();`
     - As macros procedurais de tipo função e atributo agora podem emitir
       itens `macro_rules!`, para que agora você possa fazer com que suas macros gerem macros.
     - O combinador de padrões `meta` em` macro_rules! `Agora corresponde corretamente ao
       sintaxe de atributo moderno. Por exemplo, `(# [$ m: meta])` agora corresponde
       `# [attr]`, `# [attr {tokens}]`, `# [attr [tokens]]` e `# [attr (tokens)]` `.

   + Compilador

     - Adicionado suporte de camada 3 \ * para o `thumbv7neon-unknown-linux-musleabihf`
       alvo.
     - Adicionado suporte de camada 3 para o destino `aarch64-unknown-none-softfloat`.
     - Adicionado suporte de camada 3 para o `mips64-unknown-linux-muslabi64` e
       Destinos `mips64el-unknown-linux-muslabi64`.

   + Bibliotecas

     - O método `is_power_of_two` em tipos numéricos não assinados agora é um
       função `const`.

   + APIs estabilizadas

     - BTreeMap :: get_key_value
     - HashMap :: get_key_value
     - Opção :: as_deref_mut
     - Opção :: as_deref
     - Opção :: achatar
     - UdpSocket :: peer_addr
     - f32 :: to_be_bytes
     - f32 :: to_le_bytes
     - f32 :: to_ne_bytes
     - f64 :: to_be_bytes
     - f64 :: to_le_bytes
     - f64 :: to_ne_bytes
     - f32 :: from_be_bytes
     - f32 :: from_le_bytes
     - f32 :: from_ne_bytes
     - f64 :: from_be_bytes
     - f64 :: from_le_bytes
     - f64 :: from_ne_bytes
     - mem :: take
     - fatia :: repita
     - façam!

   + Carga

     - A carga agora sempre exibirá avisos, e não apenas em novos
       constrói.
     - Sinalizadores de recurso (exceto `--all-features`) passados ​​para um espaço de trabalho virtual
       agora produzirá um erro. Anteriormente, esses sinalizadores eram ignorados.
     - Agora você pode publicar `dev-dependencies` sem incluir uma` version`.

   + Diversos

     - Agora você pode especificar o atributo `# [cfg (doctest)]` para incluir um item
       somente ao executar testes de documentação com `rustdoc`.

   + Notas de compatibilidade

     - Como anunciado anteriormente, todos os avisos anteriores da NLL na edição de 2015
       agora são erros físicos.
     - A macro `include!` Agora avisa se ela falhar ao incluir toda a
       Arquivo. A macro `include!` Involuntariamente inclui apenas a primeira
       _expression_ em um arquivo, e isso pode não ser intuitivo. Isso se tornará
       um erro grave em uma versão futura ou o comportamento pode ser corrigido
       para incluir todas as expressões conforme o esperado.
     - Usar `# [inline]` em protótipos de funções e consts agora emite um
       aviso sob fuso `unused_attribute`. Usando `# [inline]` em qualquer outro lugar
       traços internos
       ou blocos externos agora emitem corretamente um erro grave.

   Atualize para a versão 1.39.0

   + Idioma

     - Agora você pode criar funções e blocos assíncronos com async fn, async
       mova {} e assíncrono {} respectivamente, e agora você pode chamar .await em
       expressões assíncronas.
     - Agora você pode usar certos atributos em função, fechamento e função
       parâmetros do ponteiro.
     - Agora você pode usar referências compartilhadas para padrões de ligação por movimentação no if
       guardas de armas de jogo.

   + Compilador

     - Adicionado suporte de camada 3 para o destino i686-unknown-uefi.
     - Adicionado suporte de camada 3 para o destino sparc64-unknown-openbsd.
     - rustc agora cortará trechos de código nos diagnósticos para caber no seu
       terminal.
     - Agora você pode passar o argumento --show-output para testar os binários para imprimir o
       saída de testes bem-sucedidos.

   + Para mais detalhes:
   https://github.com/rust-lang/rust/blob/stable/RELEASES.md#version-1390-2019
     -11-07

   - Alterne para a versão empacotada do libgit2 por enquanto. libgit2-sys parece
     espere usar a variante agrupada, que parece apontar para um
     instantâneo da ramificação principal e não corresponde a nenhuma libgit2 liberada
     (bsc # 1154817). Consulte: https://github.com/rust-lang/rust/issues/63476 e
     https://github.com/rust-lang/git2-rs/issues/458 para obter detalhes.

   Atualize para a versão 1.38.0

   + Idioma

     - O atributo `# [global_allocator]` agora pode ser usado em submódulos.
     - O atributo `# [obsoleto]` agora pode ser usado em macros.

   + Compilador

     - Adicionado suporte de compilação em pipeline ao `rustc`. Isso vai melhorar
       tempos de compilação em alguns casos.

   + Bibliotecas

     - `ascii :: EscapeDefault` agora implementa` Clone` e `Display`.
     - Derivar macros para características de prelúdio (por exemplo, `Clone`,` Debug`, `Hash`) são
       agora disponível no mesmo caminho que a característica. (por exemplo, o `Clone` deriva
       macro está disponível em `std :: clone :: Clone`). Isso também torna tudo
       macros embutidas disponíveis na raiz `std` /` core`. por exemplo
       `std :: include_bytes!`.
     - `str :: Chars` agora implementa` Debug`.
     - `slice :: {concat, connect, join}` agora aceita `& [T]` além de
       `& T`.
     - `* const T` e` * mut T` agora implementam `marker :: Unpin`.
     - `Arc <[T]>` e `Rc <[T]>` agora implementam `FromIterator`.
     - Adicionadas operações euclidianas de restante e divisão (`div_euclid`,
       rem_euclid) para todas as primitivas numéricas. Além disso, `marcado`,
       Versões `overflowing` e` wrapping` estão disponíveis para todos os números inteiros
       primitivos.
     - `thread :: AccessError` agora implementa` Clone`, `Copy`,` Eq`, `Error`,
       e `PartialEq`.
     + `iter :: {StepBy, Peekable, Take}` agora implementa `DoubleEndedIterator`.

   + APIs estabilizadas

     - `<* const T> :: cast`
     - `<* mut T> :: cast`
     - `Duration :: as_secs_f32`
     - `Duration :: as_secs_f64`
     - `Duration :: div_f32`
     - `Duration :: div_f64`
     - `Duration :: from_secs_f32`
     - `Duration :: from_secs_f64`
     - `Duration :: mul_f32`
     - `Duration :: mul_f64`
     - `any :: type_name`

   + Carga

     - Adicionado suporte de compilação em pipeline ao `cargo`.
     - Agora você pode passar a opção `--features` várias vezes para ativar
       vários recursos.

   + Diversos

     - `rustc` avisará agora sobre alguns usos incorretos de
       `mem :: {não inicializado, zerado}` que são conhecidos por causar indefinidos
       comportamento.

   Atualize para a versão 1.37.0

     + Idioma

       - # [must_use] agora avisa se o tipo está contido em uma tupla, Box,
         ou uma matriz e não utilizada.
       - Agora você pode usar os atributos `cfg` e` cfg_attr` em genéricos
         parâmetros.
       - Agora você pode usar variantes de enumeração por meio de alias de tipo. por exemplo, você pode escrever
         o seguinte: `` type myOption = Option; fn
         increment_or_zero (x: MyOption) -> u8 {corresponde a x {MyOption :: Some (y)
         => y + 1, MyOption :: None => 0,}} `` `
       - Agora você pode usar `_` como um identificador para consts. por exemplo, você pode escrever
         `const_: u32 = 5;`.
       - Agora você pode usar `# [repr (align (X)]` em enumerações.
       - O operador macro `? Kleene já está disponível na edição de 2015.

     + Compilador

       - Agora você pode ativar a Otimização Guiada por Perfil com o comando -C
         sinalizadores de perfil-gerar` e `-C perfil de uso`. Para maiores informações
         sobre como usar a otimização guiada por perfil, consulte o rustc
         livro.
       + O script wrapper `rust-lldb` deve agora funcionar novamente.

     + Bibliotecas

       - `mem :: MaybeUninit`agora é compatível com ABI com` T`.

     + APIs estabilizadas

       - BufReader :: buffer
       - BufWriter :: buffer
       - Celular :: from_mut
       - Célula <[T]> :: as_slice_of_cells
       - Célula:: as_slice_of_cells
       - DoubleEndedIterator :: nth_back
       - Opção :: xor
       - Embalagem :: reverse_bits
       - i128 :: reverse_bits
       - i16 :: reverse_bits
       - i32 :: reverse_bits
       - i64 :: reverse_bits
       - i8 :: reverse_bits
       - isize :: reverse_bits
       - fatia :: copy_within
       - u128 :: reverse_bits
       - u16 :: reverse_bits
       - u32 :: reverse_bits
       - u64 :: reverse_bits
       - u8 :: reverse_bits
       - usize :: reverse_bits

     + Carga

       - Os arquivos Cargo.lock agora são incluídos por padrão ao publicar
         caixas executáveis ​​com executáveis.
       - Agora você pode especificar `default-run =" foo "` em `[package]` para especificar
         o executável padrão a ser usado para `` cargo run ''.
       - o vendedor de carga agora é fornecido como um subcomando de carga

     + Notas de compatibilidade

       - Usar `...` para padrões de intervalo inclusivos agora avisa por padrão.
         Faça a transição do seu código para usar a sintaxe `.. =` para inclusão
         varia em vez disso.
       + Usar um objeto de característica sem o `dyn` agora avisará por padrão.
         Faça a transição do seu código para usar o `dyn Trait` para objetos de características
         em vez de. Caranguejo (String), Lagosta (String), Pessoa (String), deixe estado =
         Criatura :: Caranguejo ("Ferris"); se deixar Criatura :: Caranguejo (nome) |
         Criatura :: Pessoa (nome) = estado {println! ("O nome desta criatura é:
         {} ", nome);} não seguro {foo ()} pub fn new (x: i32, y: i32) -> Próprio {
         Self (x, y)} pub fn is_origin (& self) -> bool {corresponde a self {Self (0,
         0) => verdadeiro, _ => falso,}} Auto: PartialOrd // pode escrever
         `Self 'em vez de` List`Zero, Contras (T, Caixa) // da mesma forma aqui
         teste fn (& self) {println! ("one"); } // ~ ERRO definições duplicadas
         com o nome `test` fn test (& self) {println! (" two "); }

   * Macros procedurais básicos que permitem `# [derivar]` personalizado, também conhecido como "macros 1.1",
     são estáveis. Isso permite caixas geradoras de código populares como Serde e
     Diesel para trabalhar ergonomicamente. [RFC 1681].
   * [As estruturas da tupla podem estar vazias. Estruturas de tupla unárias e vazias podem ser
     instanciado com chaves [36868]. Parte da [RFC 1506].
   * [Várias pequenas alterações na resolução de nomes foram
     ativado] [37127]. Eles somam semânticas mais consistentes, permitindo
     para evolução futura de macros Rust. Especificado na [RFC 1560], consulte seu
     seção sobre ["alterações"] para obter detalhes sobre o que é diferente. A quebra
     as alterações aqui foram transferidas através do [[legacy_imports`] fiapo
     desde 1,14, sem regressões conhecidas.
   * [Em macro_rules`, os fragmentos `path` agora podem ser analisados ​​como parâmetro de tipo
     limites] [38279]
   * [`? Sized` pode ser usado nas cláusulas` where`] [37791]
   * [Agora existe um limite no tamanho dos tipos monomorfizados e pode ser
     modificado com o atributo de caixa `#! [type_size_limit]`, semelhante a
     o atributo `#! [recursion_limit]`] [37789]
   * [No Windows, o compilador aplicará atributos dllimport ao vincular
     para funções externas] [37973]. Atributos e sinalizadores adicionais podem controlar
     qual tipo de biblioteca está vinculado e seu nome. [RFC 1717].
   * [Os símbolos Rust-ABI não são mais exportados de cdylibs] [38117]
   * [O sinalizador `--test` funciona com caixas de macro procedurais] [38107]
   * [Corrigir ABI `extern" aapcs "fn`] [37814]
   * [O sinalizador `-C no-stack-check` está obsoleto] [37636]. Não faz nada.
   * [O expansor `format!` Reconhece `printf` incorreto e estilo shell
     diretivas de formatação e sugere o formato correto] [37613].
   * [Relate apenas um erro para todas as importações não utilizadas em uma lista de importação] [37456]
   * [Evite chamadas desnecessárias do `mk_ty` em` Ty :: super_fold_with`] [37705]
   * [Evite mais chamadas desnecessárias do `mk_ty` em` Ty :: super_fold_with`] [37979]
   * [Não clone em `UnificationTable :: probe`] [37848]
   * [Remova o `scope_auxiliary` para reduzir o RSS em 10%] [37764]
   * [Use vetores pequenos no tipo walker] [37760]
   * [O desempenho da expansão macro foi aprimorado] [37701]
   * [Alterar `HirVec> `para` HirVec`em` hir :: Expr`] [37642]
   * [Substitua FNV por uma função de hash mais rápida] [37229]
     https://raw.githubusercontent.com/rust-lang/rust/master/RELEASES.md

   rust-cbindgen é enviado na versão 0.14.1.


Instruções de patch:

   Para instalar esta atualização de segurança do openSUSE, use os métodos de instalação recomendados pelo SUSE
   como o YaST online_update ou "zypper patch".

   Como alternativa, você pode executar o comando listado para o seu produto:

   - openSUSE Leap 15.2:

      zypper no patch -t openSUSE-2020-945 = 1



Lista de Pacotes:

   - openSUSE Leap 15.2 (i586 x86_64):

      cargo-1.43.1-lp152.3.5.1
      clippy-1.43.1-lp152.3.5.1
      rls-1.43.1-lp152.3.5.1
      ferrugem-1.43.1-lp152.3.5.1
      ferrugem-análise-1.43.1-lp152.3.5.1
      ferrugem-doc-1.43.1-lp152.3.5.1
      ferrugem-gdb-1.43.1-lp152.3.5.1
      rust-std-static-1.43.1-lp152.3.5.1
      rustfmt-1.43.1-lp152.3.5.1

   - openSUSE Leap 15.2 (noarch):

      cargo-doc-1.43.1-lp152.3.5.1
      rust-src-1.43.1-lp152.3.5.1

   - openSUSE Leap 15.2 (x86_64):

      ferrugem-cbindgen-0.14.1-lp152.2.4.1


Referências:

   https://www.suse.com/security/cve/CVE-2020-1967.html
   https://bugzilla.suse.com/1115645
   https://bugzilla.suse.com/1154817
   https://bugzilla.suse.com/1173202

-



Fonte

Até a próxima !!

Nenhum comentário:

Postar um comentário