Uma réplica é uma cópia de um log que não é seu. Ela guarda os mesmos registros, textos cifrados, marcadores de exclusão e, se os peers do dono os compartilharem, as chaves das entradas. Ela é somente leitura: só o dono pode adicionar entradas.
Abrir uma réplica
Uma réplica começa a partir de três coisas: a chave pública do dono, o ID
do log e o cabeçalho do log assinado pelo dono. Ela nunca precisa de uma
chave privada. Uma Replica da kolo-log guarda
na memória só os hashes da árvore e os registros, e as suas entradas em um
Storage. NewReplica cria uma sobre um armazenamento vazio, e
RestoreReplica abre a réplica de novo a partir desse armazenamento e dos
heads guardados, lendo as entradas uma por vez e verificando cada uma. A
kolo-store mantém uma réplica em disco, com
cerca de 250 bytes de memória por entrada. Um store guarda um log por ID de
log, então uma réplica do log de outro dono com o mesmo ID de um log
guardado precisa de outro store.
Fazer uma réplica crescer
Update recebe um head assinado mais novo, uma prova de consistência e as
novas entradas. Ele verifica a assinatura do head, a prova, cada registro e
texto cifrado, cada chave com o seu compromisso e a raiz reconstruída. Se
qualquer verificação falhar, ele não guarda nada, e a réplica fica
exatamente como estava. Cada mudança é gravada com um commit no
armazenamento antes de aparecer.
- Se o dono assinou dois históricos diferentes,
UpdateretornaErrDiverged, e os dois heads assinados são a prova. - Um head mais antigo do mesmo histórico retorna
ErrRollback. Um head mais antigo cuja raiz não bate com as entradas guardadas retornaErrDiverged.
Uma entrada pode chegar sem a sua chave, se o peer que serve não compartilha
as chaves. Ela é lida como ErrKeyUnavailable até que AddKey lhe dê a
chave, depois de verificá-la com o compromisso do registro. Outra chave para
uma entrada que já tem uma é ErrBadEntry.
Key e EntryInfo dão a uma camada de sincronização a chave de uma entrada,
e se ela está excluída ou tem chave, sem ler o seu texto cifrado.
OpenEntry verifica uma entrada buscada sozinha contra um head verificado e
a sua prova de inclusão.
Atualizar em etapas
Uma réplica muito atrasada se atualiza em blocos. Update aceita entradas
que param antes do novo head, verificadas por uma prova de consistência
contra a raiz que a própria réplica reconstruiu. Head continua sendo o
último head do qual a réplica tem todas as entradas, então Len pode ser
maior durante uma atualização.
Target retorna o head que está sendo preenchido e a sua prova. A réplica
grava os dois com cada bloco, então o seu armazenamento sempre tem o que
RestoreReplica precisa, e o alvo passa de novo pelas verificações de
Update na restauração (OpenReplica na kolo-store), então uma atualização
continua depois de um reinício. Enquanto há um alvo pendente, um head entre
Len e o tamanho do alvo é recusado sem verificação com ErrRollback, que
ali não quer dizer que o head compartilha o histórico da réplica. Um bloco
rumo a um head maior precisa chegar ao tamanho do alvo (ErrBadEntry), e a
raiz reconstruída no tamanho do alvo precisa bater (ErrDiverged).
Só pull
Um pull entre dois peers
Quem faz o pull pede e confere; o servidor só responde. Nada é gravado antes de ser verificado.
- Quem faz o pull abre um stream na sua conexão kolo-secure e envia HEAD_REQ com a chave do dono e o ID do log.
- O servidor pergunta à sua função authorize sobre esse peer e esse log. Um log que ele não oferece e um peer sem acesso recebem o mesmo erro de não encontrado. Se não, ele responde HEAD: o head assinado e o cabeçalho do log.
- Quem faz o pull confere a assinatura do head. Se já tem um head anterior, PROOF_REQ pede uma prova de consistência de que o novo o estende.
- ENTRIES_REQ pede o intervalo que falta. Cada resposta tem no máximo 4 MiB, e Replica.Update confere cada registro e cada prova antes de gravar qualquer coisa.
- STATE_REQ pede os marcadores de exclusão e as chaves. Quem faz o pull confere e aplica os marcadores, depois adiciona as chaves.
- Quem faz o pull fecha o stream. O servidor nunca escreve em quem faz o pull: kolo-sync é só pull.
A kolo-sync copia um log entre peers, e só por pull. O peer que quer a cópia pede; o peer que serve nunca escreve para ninguém. Qualquer peer com uma cópia verificada pode servi-la, porque a confiança vem das assinaturas do dono e não do peer que enviou os bytes.
Um log é identificado pela chave do dono e pelo ID do log quando é servido e sincronizado. O lado que serve decide, para cada peer e cada log, se o peer não recebe nada, recebe só o texto cifrado ou recebe o texto cifrado e as chaves.
Uma resposta STATE olha no máximo 32.768 entradas e lê só os marcadores de exclusão e as chaves que envia, e quem faz o pull pede o resto. Um pull sem nada novo não lê nenhum texto cifrado em nenhum dos lados. Um pull que para no meio deixa um alvo na kolo-store; o próximo pull preenche esse alvo primeiro e retorna nil se o head do peer estiver abaixo dele. Uma entrada cujo texto cifrado com preenchimento não cabe em uma mensagem não pode ser sincronizada, excluída ou não, e o log não sincroniza além dela.
Fetch lê um intervalo de entradas sem réplica, contra um head em que o
cliente confia: um de FetchHead ou o head de uma réplica. Cada entrada é
verificada contra esse head com a sua prova de inclusão, e um peer cujo head
está atrás dele dá ErrBehind.
Peers de fixação
Um peer de fixação da kolo-pin é uma réplica que
mantém o log de um dono disponível enquanto o dono está offline. Ele puxa o
log com acesso Ciphertext, então guarda os registros, os textos cifrados e
os marcadores de exclusão, mas nunca as chaves das entradas, e não consegue
ler as entradas. Os outros peers puxam o texto cifrado dele, ou pedem um
intervalo de entradas, como de qualquer réplica, pela chave do dono e pelo
ID do log, e recebem as chaves dos próprios aparelhos do dono.
Leitores na kolo-kv
Um leitor da kolo-kv mostra o maior prefixo da sua
réplica que ele consegue reproduzir exatamente, até o último head
verificado completo. Ele para na primeira entrada guardada sem a sua chave,
e antes de uma entrada destruída cuja entrada de exclusão ele ainda não tem.
Len informa esse prefixo e pode diminuir depois de um Refresh: o leitor
volta atrás em vez de mostrar um estado que o escritor nunca teve. Ele só
muda de estado com Refresh, exceto pelos valores destruídos, que passam a
ser lidos como ausentes na hora.
O que “de melhor esforço” quer dizer aqui
Uma réplica aplica os marcadores de exclusão que puxa: ela destrói a chave da entrada e mantém o registro assinado e o marcador. Isso vale em todos os peers que seguem o protocolo. Um peer que já tinha a chave antes de o marcador chegar pode guardar uma cópia dela. Veja Exclusão.