user180574's questions

O trecho de código a seguir chama a select()função.

n = select(max_fd, NULL, &write_set, NULL, NULL)

Ele verifica a disponibilidade de gravação em alguns soquetes. Como geralmente está disponível, o tempo limite não é definido. Em certas iterações do loop, é possível que write_setesteja vazio.

Abaixo está o rastreamento. Não há mais saída, então presumo que o programa trave.

select(7, NULL, [], NULL, NULL

Minha pergunta é: esse é o comportamento correto? Se o conjunto estiver vazio, o select deve retornar imediatamente? Não há motivo para select()esperar, certo?

Eu tenho um arquivo protobuf como abaixo.

syntax = "proto3";

message Message {
   repeated bytes data = 1;
}

Este é o código Python.

import test_pb2
message = test_pb2.Message()
with open("test.dat", mode='rb') as file:
   message.data.extend(file.read())

Este é o erro.

Traceback (most recent call last):
  File "./test.py", line 7, in <module>
    message.data.extend(file.read())
TypeError: 48 has type int, but expected one of: bytes

Também tento "read_bytes ()", erro semelhante.

O código a seguir funciona bem.

x = list()
with open("test.dat", mode='rb') as file:
   x.extend(file.read())

Aparentemente, o objeto repetido não funciona como uma lista.

Eu tenho o seguinte código. Chamar f1 gera segfault, mas não f2.

#include <stdlib.h>
#include <stdio.h>

void f1(unsigned char** arr)
{
   unsigned char* p = *arr;
   *p = 'h';
   p++;
   *p = '\0';
}

void f2(unsigned char* arr)
{
   unsigned char* p = arr;
   *p = 'h';
   p++;
   *p = '\0';
}

int main()
{
   unsigned char a[31];
   f1((unsigned char**)&a);
   //f2(a);
   printf("%s\n", a);
}

Tenho um erro de compilação de "tipo de ponteiro incompatível" com o código a seguir.

f(unsigned char** arr)
{
   unsigned char* p = *arr;
}

int main()
{
   unsigned char a[31];
   f(&a);
}

Gostaria de entender por que e como consertar.

Editar

Desculpe, omiti um ponto.

Quando compilo com o gcc, é apenas um aviso, mas o g++ gera isso como erro.

cannot convert ‘unsigned char (*)[31]’ to ‘unsigned char**’`

Quero corrigir o erro ao usar g++.

Eu tenho o seguinte código python que cria um dado DER "x25519_pubic_der".

#!/usr/bin/python3

from cryptography.hazmat.primitives.asymmetric import x25519
from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat

x25519_key = x25519.X25519PrivateKey.generate()
x25519_public_der = x25519_key.public_key().public_bytes(Encoding.DER,
                                                         PublicFormat.SubjectPublicKeyInfo)

Tento decodificar esse dado de volta aos bits binários originais usando o código C, mas não funciona. Abaixo está um programa de teste (assumindo que os dados foram transferidos corretamente, também o comprimento).

const unsigned char* ptr = x25519_public_der;
ASN1_OCTET_STRING* octet_string = d2i_ASN1_OCTET_STRING(NULL, &ptr, x25519_public_der_len);
if (!octet_string) {
   fprintf(stderr, "Error decoding DER data to binary bytes\n");
   return 1;
}

Suspeito que PublicFormat.SubjectPublicKeyInfo possa adicionar alguma codificação extra ou não estou usando a função d2i_ correta (?), apenas um palpite...

Basicamente x25519_public_der contém 44 bytes e quero restaurá-lo para 32 bytes usando programação C. Acho que esta questão pode ser relevante: como passo uma chave pública x25519 de 44 bytes criada pelo openssl para o CryptoKit que requer um comprimento de chave de 32 bytes , mas não tenho experiência suficiente para implementá-la em C.

Tento converter uma string de carimbo de data/hora em tempo de época unix usando awk, mas falho após várias tentativas.

$ echo "2024-04-16 16:32:38.108580" | awk '{ epoch = mktime(gensub(/[:-]/, " ", "g", $1)) + substr($1, index($1, ".")+1) ; print epoch }'
2023

Tento testar o código de exemplo em https://www.openssl.org/docs/man1.1.1/man3/EVP_PKEY_CTX_set1_hkdf_salt.html (com algumas modificações). Quando eu o executo, a chamada de função EVP_PKEY_derive retorna 0, mas nenhum código de erro claro.

#include <openssl/err.h>
#include <openssl/evp.h>
#include <openssl/kdf.h>


int main()
{
   char error[1024];

   if (EVP_PKEY_CTX* pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL))
   {
      unsigned char out[1024];
      size_t outlen = sizeof(out);
      
      if (EVP_PKEY_derive_init(pctx) <= 0                     ||
          EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()) <= 0   ||
          EVP_PKEY_CTX_set1_hkdf_salt(pctx, "salt", 4) <= 0   ||
          EVP_PKEY_CTX_set1_hkdf_key(pctx, "secret", 6) <= 0  ||
          EVP_PKEY_CTX_add1_hkdf_info(pctx, "label", 5) <= 0  )
      {
         ERR_error_string(ERR_get_error(), error);
         printf("%s\n", error);
      }
      else
      {
         int r = EVP_PKEY_derive(pctx, NULL, &outlen);
         if (r <= 0)
         {
            ERR_error_string(ERR_get_error(), error);
            printf("EVP_PKEY_derive: %d, %s\n", r, error);
         }
         else
         {
            printf("%d\n", outlen);
         }
      }

      EVP_PKEY_CTX_free(pctx);
   }

   return 0;
}

Abaixo está a saída.

EVP_PKEY_derive: 0, error:00000000:lib(0):func(0):reason(0)

Aliás, o openssl que estou usando é 1.1.1k.

Tente compilar o seguinte código.

#include <string>

#include <boost/any.hpp>


class V
{
public:
   V& operator=(int i)
   {
      v = i;
      return *this;
   }
   V& operator=(const std::string& s)
   {
      v = s;
      return *this;
   }
   operator int() const
   {
      return boost::any_cast<int>(v);
   }
   operator std::string() const
   {
      return boost::any_cast<std::string>(v);
   }
private:
   boost::any v;
};


int main()
{
   V v;
   std::string s1 = "hello", s2;
   v = s1;
   s2 = v;
}

Abaixo está o erro.

$ g++ test__boost_any.cpp
test__boost_any.cpp: In function ‘int main()’:
test__boost_any.cpp:37:9: error: ambiguous overload for ‘operator=’ (operand types are ‘std::__cxx11::string’ {aka ‘std::__cxx11::basic_string<char>’} and ‘V’)
    s2 = v;
         ^
In file included from /usr/include/c++/8/string:52,
                 from test__boost_any.cpp:1:
/usr/include/c++/8/bits/basic_string.h:668:7: note: candidate: ‘std::__cxx11::basic_string<_CharT, _Traits, _Alloc>& std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::operator=(const std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>]’
       operator=(const basic_string& __str)
       ^~~~~~~~
/usr/include/c++/8/bits/basic_string.h:718:7: note: candidate: ‘std::__cxx11::basic_string<_CharT, _Traits, _Alloc>& std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::operator=(_CharT) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>]’
       operator=(_CharT __c)
       ^~~~~~~~
/usr/include/c++/8/bits/basic_string.h:736:7: note: candidate: ‘std::__cxx11::basic_string<_CharT, _Traits, _Alloc>& std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::operator=(std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>]’
       operator=(basic_string&& __str)
       ^~~~~~~~