908 lines
29 KiB
Rust
908 lines
29 KiB
Rust
use std::{
|
|
fs,
|
|
path::Path,
|
|
sync::{Arc, Mutex, mpsc},
|
|
thread,
|
|
time::Duration,
|
|
};
|
|
|
|
use russh::{
|
|
Channel, ChannelId, Sig,
|
|
keys::{PrivateKey, PublicKey, ssh_key::Algorithm},
|
|
server,
|
|
};
|
|
use sha1::{Digest as _, Sha1};
|
|
|
|
use super::{
|
|
GitCredential, GitCredentialProvider, GitError, GitIdentity, GitOperationControl,
|
|
GitRepository, PullOutcome, SshPassphraseProvider, build_pack,
|
|
};
|
|
use crate::{
|
|
config::{GitRemote, SshFingerprint, SshRemoteAuthentication},
|
|
repository::{Repository, SecretBytes},
|
|
};
|
|
|
|
#[derive(Clone, Copy)]
|
|
enum ReceiveBehavior {
|
|
Success,
|
|
NonFastForward,
|
|
Reject,
|
|
UnpackFailure,
|
|
MalformedStatus,
|
|
EarlyEof,
|
|
NonZero,
|
|
Signal,
|
|
Disconnect,
|
|
SlowSuccess,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
struct UploadFixture {
|
|
advertisement: Vec<u8>,
|
|
pack: Vec<u8>,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct Observed {
|
|
commands: Vec<Vec<u8>>,
|
|
receive_requests: Vec<Vec<u8>>,
|
|
}
|
|
|
|
#[derive(Clone, Copy)]
|
|
enum Service {
|
|
Upload,
|
|
Receive,
|
|
}
|
|
|
|
struct GitServerHandler {
|
|
user_key: PublicKey,
|
|
upload: Option<UploadFixture>,
|
|
advertised_receive_tip: Option<String>,
|
|
receive_behavior: ReceiveBehavior,
|
|
malformed_upload: bool,
|
|
observed: Arc<Mutex<Observed>>,
|
|
service: Option<Service>,
|
|
input: Vec<u8>,
|
|
saw_want: bool,
|
|
saw_have: bool,
|
|
}
|
|
|
|
impl Clone for GitServerHandler {
|
|
fn clone(&self) -> Self {
|
|
Self {
|
|
user_key: self.user_key.clone(),
|
|
upload: self.upload.clone(),
|
|
advertised_receive_tip: self.advertised_receive_tip.clone(),
|
|
receive_behavior: self.receive_behavior,
|
|
malformed_upload: self.malformed_upload,
|
|
observed: Arc::clone(&self.observed),
|
|
service: None,
|
|
input: Vec::new(),
|
|
saw_want: false,
|
|
saw_have: false,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl server::Handler for GitServerHandler {
|
|
type Error = russh::Error;
|
|
|
|
async fn auth_publickey(
|
|
&mut self,
|
|
user: &str,
|
|
public_key: &PublicKey,
|
|
) -> Result<server::Auth, Self::Error> {
|
|
Ok(if user == "git" && public_key == &self.user_key {
|
|
server::Auth::Accept
|
|
} else {
|
|
server::Auth::reject()
|
|
})
|
|
}
|
|
|
|
async fn channel_open_session(
|
|
&mut self,
|
|
_channel: Channel<server::Msg>,
|
|
reply: server::ChannelOpenHandle,
|
|
_session: &mut server::Session,
|
|
) -> Result<(), Self::Error> {
|
|
reply.accept().await;
|
|
Ok(())
|
|
}
|
|
|
|
async fn exec_request(
|
|
&mut self,
|
|
channel: ChannelId,
|
|
command: &[u8],
|
|
session: &mut server::Session,
|
|
) -> Result<(), Self::Error> {
|
|
self.observed
|
|
.lock()
|
|
.expect("observed")
|
|
.commands
|
|
.push(command.to_vec());
|
|
if command.starts_with(b"git-upload-pack '") && command.ends_with(b"'") {
|
|
self.service = Some(Service::Upload);
|
|
session.channel_success(channel)?;
|
|
if self.malformed_upload {
|
|
session.data(channel, b"zzzz".to_vec())?;
|
|
session.close(channel)?;
|
|
} else if let Some(upload) = &self.upload {
|
|
session.data(channel, upload.advertisement.clone())?;
|
|
} else {
|
|
session.channel_failure(channel)?;
|
|
}
|
|
} else if command.starts_with(b"git-receive-pack '") && command.ends_with(b"'") {
|
|
self.service = Some(Service::Receive);
|
|
session.channel_success(channel)?;
|
|
session.data(
|
|
channel,
|
|
receive_advertisement(self.advertised_receive_tip.as_deref()),
|
|
)?;
|
|
} else {
|
|
session.channel_failure(channel)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
async fn data(
|
|
&mut self,
|
|
channel: ChannelId,
|
|
data: &[u8],
|
|
session: &mut server::Session,
|
|
) -> Result<(), Self::Error> {
|
|
match self.service {
|
|
Some(Service::Receive) => self.input.extend_from_slice(data),
|
|
Some(Service::Upload) => self.upload_data(channel, data, session)?,
|
|
None => session.close(channel)?,
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
async fn channel_eof(
|
|
&mut self,
|
|
channel: ChannelId,
|
|
session: &mut server::Session,
|
|
) -> Result<(), Self::Error> {
|
|
if matches!(self.service, Some(Service::Receive)) {
|
|
self.observed
|
|
.lock()
|
|
.expect("observed")
|
|
.receive_requests
|
|
.push(self.input.clone());
|
|
self.finish_receive(channel, session).await?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl GitServerHandler {
|
|
fn upload_data(
|
|
&mut self,
|
|
channel: ChannelId,
|
|
data: &[u8],
|
|
session: &mut server::Session,
|
|
) -> Result<(), russh::Error> {
|
|
self.input.extend_from_slice(data);
|
|
while self.input.len() >= 4 {
|
|
let Some(length) = std::str::from_utf8(&self.input[..4])
|
|
.ok()
|
|
.and_then(|value| usize::from_str_radix(value, 16).ok())
|
|
else {
|
|
session.close(channel)?;
|
|
return Ok(());
|
|
};
|
|
if length == 0 {
|
|
self.input.drain(..4);
|
|
if !self.saw_want {
|
|
session.exit_status_request(channel, 0)?;
|
|
session.eof(channel)?;
|
|
session.close(channel)?;
|
|
return Ok(());
|
|
} else if self.saw_have {
|
|
session.data(channel, packet(b"NAK\n"))?;
|
|
self.saw_have = false;
|
|
}
|
|
continue;
|
|
}
|
|
if length < 4 || self.input.len() < length {
|
|
break;
|
|
}
|
|
let line = self.input[4..length].to_vec();
|
|
self.input.drain(..length);
|
|
if line.starts_with(b"want ") {
|
|
self.saw_want = true;
|
|
} else if line.starts_with(b"have ") {
|
|
self.saw_have = true;
|
|
} else if line == b"done\n" || line == b"done" {
|
|
session.data(channel, packet(b"NAK\n"))?;
|
|
if let Some(upload) = &self.upload {
|
|
for chunk in upload.pack.chunks(997) {
|
|
let mut sideband = Vec::with_capacity(chunk.len() + 1);
|
|
sideband.push(1);
|
|
sideband.extend_from_slice(chunk);
|
|
session.data(channel, packet(&sideband))?;
|
|
}
|
|
}
|
|
session.data(channel, b"0000".to_vec())?;
|
|
session.exit_status_request(channel, 0)?;
|
|
session.eof(channel)?;
|
|
session.close(channel)?;
|
|
return Ok(());
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
async fn finish_receive(
|
|
&self,
|
|
channel: ChannelId,
|
|
session: &mut server::Session,
|
|
) -> Result<(), russh::Error> {
|
|
let reference = receive_reference(&self.input).unwrap_or("refs/heads/main");
|
|
match self.receive_behavior {
|
|
ReceiveBehavior::Success => {
|
|
if self.input == b"0000" {
|
|
session.exit_status_request(channel, 0)?;
|
|
} else {
|
|
send_status(
|
|
session,
|
|
channel,
|
|
b"unpack ok\n",
|
|
format!("ok {reference}\n"),
|
|
)?;
|
|
}
|
|
}
|
|
ReceiveBehavior::NonFastForward => send_status(
|
|
session,
|
|
channel,
|
|
b"unpack ok\n",
|
|
format!("ng {reference} non-fast-forward\n"),
|
|
)?,
|
|
ReceiveBehavior::Reject => send_status(
|
|
session,
|
|
channel,
|
|
b"unpack ok\n",
|
|
format!("ng {reference} protected branch\n"),
|
|
)?,
|
|
ReceiveBehavior::UnpackFailure => {
|
|
send_status(session, channel, b"unpack corrupt pack\n", String::new())?
|
|
}
|
|
ReceiveBehavior::MalformedStatus => {
|
|
session.data(channel, b"zzzz".to_vec())?;
|
|
session.exit_status_request(channel, 0)?;
|
|
}
|
|
ReceiveBehavior::EarlyEof => {
|
|
session.eof(channel)?;
|
|
session.close(channel)?;
|
|
return Ok(());
|
|
}
|
|
ReceiveBehavior::Disconnect => {
|
|
session.close(channel)?;
|
|
return Ok(());
|
|
}
|
|
ReceiveBehavior::NonZero => {
|
|
session.extended_data(channel, 1, b"receive-pack failed\n".to_vec())?;
|
|
session.exit_status_request(channel, 7)?;
|
|
}
|
|
ReceiveBehavior::Signal => {
|
|
session.exit_signal_request(channel, Sig::TERM, false, "killed", "")?;
|
|
}
|
|
ReceiveBehavior::SlowSuccess => {
|
|
tokio::time::sleep(Duration::from_millis(500)).await;
|
|
send_status(
|
|
session,
|
|
channel,
|
|
b"unpack ok\n",
|
|
format!("ok {reference}\n"),
|
|
)?;
|
|
}
|
|
}
|
|
session.eof(channel)?;
|
|
session.close(channel)
|
|
}
|
|
}
|
|
|
|
fn send_status(
|
|
session: &mut server::Session,
|
|
channel: ChannelId,
|
|
unpack: &[u8],
|
|
reference: String,
|
|
) -> Result<(), russh::Error> {
|
|
session.data(channel, packet(unpack))?;
|
|
if !reference.is_empty() {
|
|
session.data(channel, packet(reference.as_bytes()))?;
|
|
}
|
|
session.data(channel, b"0000".to_vec())?;
|
|
session.exit_status_request(channel, 0)
|
|
}
|
|
|
|
struct TestServer {
|
|
port: u16,
|
|
host_key: PrivateKey,
|
|
observed: Arc<Mutex<Observed>>,
|
|
join: thread::JoinHandle<()>,
|
|
}
|
|
|
|
fn start_server(
|
|
user_key: PublicKey,
|
|
upload: Option<UploadFixture>,
|
|
receive_tip: Option<String>,
|
|
receive_behavior: ReceiveBehavior,
|
|
malformed_upload: bool,
|
|
connections: usize,
|
|
) -> TestServer {
|
|
let host_key = key();
|
|
let observed = Arc::new(Mutex::new(Observed::default()));
|
|
let handler = GitServerHandler {
|
|
user_key,
|
|
upload,
|
|
advertised_receive_tip: receive_tip,
|
|
receive_behavior,
|
|
malformed_upload,
|
|
observed: Arc::clone(&observed),
|
|
service: None,
|
|
input: Vec::new(),
|
|
saw_want: false,
|
|
saw_have: false,
|
|
};
|
|
let server_key = host_key.clone();
|
|
let (port_tx, port_rx) = mpsc::channel();
|
|
let join = thread::spawn(move || {
|
|
tokio::runtime::Runtime::new()
|
|
.expect("server runtime")
|
|
.block_on(async move {
|
|
let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0))
|
|
.await
|
|
.expect("bind server");
|
|
port_tx
|
|
.send(listener.local_addr().expect("address").port())
|
|
.expect("send port");
|
|
let config = Arc::new(server::Config {
|
|
keys: vec![server_key],
|
|
auth_rejection_time: Duration::ZERO,
|
|
auth_rejection_time_initial: Some(Duration::ZERO),
|
|
..server::Config::default()
|
|
});
|
|
for _ in 0..connections {
|
|
let (stream, _) = listener.accept().await.expect("accept client");
|
|
if let Ok(session) =
|
|
server::run_stream(Arc::clone(&config), stream, handler.clone()).await
|
|
{
|
|
let _ = session.await;
|
|
}
|
|
}
|
|
});
|
|
});
|
|
TestServer {
|
|
port: port_rx
|
|
.recv_timeout(Duration::from_secs(5))
|
|
.expect("server port"),
|
|
host_key,
|
|
observed,
|
|
join,
|
|
}
|
|
}
|
|
|
|
struct Credentials;
|
|
|
|
impl GitCredentialProvider for Credentials {
|
|
fn credential(
|
|
&self,
|
|
_server: &crate::config::ServerId,
|
|
_application: &crate::config::ApplicationId,
|
|
) -> Result<GitCredential, GitError> {
|
|
Err(GitError::CredentialsUnavailable)
|
|
}
|
|
}
|
|
|
|
impl SshPassphraseProvider for Credentials {
|
|
fn ssh_key_passphrase(&self, fingerprint: &SshFingerprint) -> Result<SecretBytes, GitError> {
|
|
Err(GitError::SshKeyPassphraseUnavailable {
|
|
fingerprint: fingerprint.clone(),
|
|
})
|
|
}
|
|
}
|
|
|
|
fn key() -> PrivateKey {
|
|
PrivateKey::random(&mut russh::keys::key::safe_rng(), Algorithm::Ed25519).expect("generate key")
|
|
}
|
|
|
|
fn packet(data: &[u8]) -> Vec<u8> {
|
|
let mut output = format!("{:04x}", data.len() + 4).into_bytes();
|
|
output.extend_from_slice(data);
|
|
output
|
|
}
|
|
|
|
fn identity() -> GitIdentity {
|
|
GitIdentity::new("SSH Push Test", "ssh-push@ironstorage.invalid").expect("identity")
|
|
}
|
|
|
|
fn commit(git: &GitRepository, path: &str, contents: &[u8], message: &str) -> String {
|
|
fs::write(git.root().join(path), contents).expect("write worktree");
|
|
git.stage(&[path.into()]).expect("stage");
|
|
git.commit(message).expect("commit")
|
|
}
|
|
|
|
fn upload_fixture(repository: &GitRepository) -> UploadFixture {
|
|
let head = repository.repository.head_commit().expect("head").id;
|
|
let capabilities = "multi_ack_detailed side-band-64k thin-pack ofs-delta include-tag symref=HEAD:refs/heads/main";
|
|
let mut advertisement = packet(format!("{head} HEAD\0{capabilities}\n").as_bytes());
|
|
advertisement.extend_from_slice(&packet(format!("{head} refs/heads/main\n").as_bytes()));
|
|
advertisement.extend_from_slice(b"0000");
|
|
UploadFixture {
|
|
advertisement,
|
|
pack: build_pack(&repository.repository, head, None).expect("pack"),
|
|
}
|
|
}
|
|
|
|
fn receive_advertisement(tip: Option<&str>) -> Vec<u8> {
|
|
let mut output = match tip {
|
|
Some(tip) => packet(
|
|
format!("{tip} refs/heads/main\0report-status delete-refs ofs-delta\n").as_bytes(),
|
|
),
|
|
None => packet(b"0000000000000000000000000000000000000000 capabilities^{}\0report-status delete-refs ofs-delta\n"),
|
|
};
|
|
output.extend_from_slice(b"0000");
|
|
output
|
|
}
|
|
|
|
fn remote(root: &Path, server: &TestServer, identity: &PrivateKey, scp_like: bool) -> GitRemote {
|
|
let identity_file = root.join("identity");
|
|
fs::write(
|
|
&identity_file,
|
|
identity
|
|
.to_openssh(russh::keys::ssh_key::LineEnding::LF)
|
|
.expect("identity"),
|
|
)
|
|
.expect("write identity");
|
|
let known_hosts = root.join("known_hosts");
|
|
fs::write(
|
|
&known_hosts,
|
|
format!(
|
|
"[127.0.0.1]:{} {}\n",
|
|
server.port,
|
|
server.host_key.public_key().to_openssh().expect("host key")
|
|
),
|
|
)
|
|
.expect("known hosts");
|
|
let url = if scp_like {
|
|
"git@127.0.0.1:team/store.git".to_owned()
|
|
} else {
|
|
format!("ssh://git@127.0.0.1:{}/team/store.git", server.port)
|
|
};
|
|
let mut remote = GitRemote::ssh_with_authentication(
|
|
"origin",
|
|
url,
|
|
SshRemoteAuthentication::key_file(identity_file, known_hosts).expect("authentication"),
|
|
)
|
|
.expect("remote");
|
|
remote.set_ssh_test_port(server.port);
|
|
remote
|
|
}
|
|
|
|
fn local_repository(root: &Path) -> GitRepository {
|
|
fs::create_dir(root).expect("local root");
|
|
let store = Repository::open(root).expect("store");
|
|
GitRepository::init(&store, identity()).expect("Git")
|
|
}
|
|
|
|
fn receive_reference(input: &[u8]) -> Option<&str> {
|
|
let length = std::str::from_utf8(input.get(..4)?)
|
|
.ok()
|
|
.and_then(|value| usize::from_str_radix(value, 16).ok())?;
|
|
let command = std::str::from_utf8(input.get(4..length)?).ok()?;
|
|
command.split_once('\0')?.0.split_whitespace().nth(2)
|
|
}
|
|
|
|
fn tracking_id(repository: &GitRepository) -> Option<String> {
|
|
repository
|
|
.repository
|
|
.try_find_reference("refs/remotes/origin/main")
|
|
.expect("tracking lookup")
|
|
.map(|reference| reference.id().to_string())
|
|
}
|
|
|
|
fn assert_pack_request(request: &[u8], old: Option<&str>, new: &str) {
|
|
let pack_offset = request
|
|
.windows(4)
|
|
.position(|window| window == b"PACK")
|
|
.expect("pack payload");
|
|
let command = &request[..pack_offset];
|
|
assert!(
|
|
command
|
|
.windows(new.len())
|
|
.any(|window| window == new.as_bytes())
|
|
);
|
|
assert!(
|
|
command
|
|
.windows(b"refs/heads/main".len())
|
|
.any(|window| window == b"refs/heads/main")
|
|
);
|
|
if let Some(old) = old {
|
|
assert!(
|
|
command
|
|
.windows(old.len())
|
|
.any(|window| window == old.as_bytes())
|
|
);
|
|
}
|
|
let pack = &request[pack_offset..];
|
|
assert_eq!(&pack[..4], b"PACK");
|
|
assert_eq!(
|
|
u32::from_be_bytes(pack[4..8].try_into().expect("version")),
|
|
2
|
|
);
|
|
assert!(u32::from_be_bytes(pack[8..12].try_into().expect("count")) >= 3);
|
|
assert_eq!(
|
|
Sha1::digest(&pack[..pack.len() - 20]).as_slice(),
|
|
&pack[pack.len() - 20..]
|
|
);
|
|
assert!(
|
|
!request
|
|
.windows(b"PRIVATE KEY".len())
|
|
.any(|window| window == b"PRIVATE KEY")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn new_branch_fast_forward_and_already_current_push_are_confirmed() {
|
|
for scp_like in [false, true] {
|
|
for old_kind in [None, Some("base")] {
|
|
let temporary = tempfile::tempdir().expect("temporary directory");
|
|
let local = local_repository(&temporary.path().join("local"));
|
|
let base = commit(&local, ".gpg-id", b"ALICE\n", "Initialize");
|
|
let new = commit(&local, "entry.gpg", b"ciphertext", "Add entry");
|
|
let old = old_kind.map(|_| base.clone());
|
|
let user_key = key();
|
|
let server = start_server(
|
|
user_key.public_key().clone(),
|
|
None,
|
|
old.clone(),
|
|
ReceiveBehavior::Success,
|
|
false,
|
|
1,
|
|
);
|
|
let remote = remote(temporary.path(), &server, &user_key, scp_like);
|
|
let mut local = local;
|
|
local.add_remote("origin", remote.url()).expect("remote");
|
|
let outcome = local
|
|
.push(&remote, Some("main"), &Credentials)
|
|
.expect("push");
|
|
assert_eq!(outcome.new_id(), new);
|
|
assert_eq!(tracking_id(&local), Some(new.clone()));
|
|
server.join.join().expect("server");
|
|
let observed = server.observed.lock().expect("observed");
|
|
let expected = if scp_like {
|
|
b"git-receive-pack 'team/store.git'".to_vec()
|
|
} else {
|
|
b"git-receive-pack '/team/store.git'".to_vec()
|
|
};
|
|
assert_eq!(observed.commands, [expected]);
|
|
assert_eq!(observed.receive_requests.len(), 1);
|
|
assert_pack_request(&observed.receive_requests[0], old.as_deref(), &new);
|
|
}
|
|
}
|
|
|
|
for scp_like in [false, true] {
|
|
let temporary = tempfile::tempdir().expect("temporary directory");
|
|
let local = local_repository(&temporary.path().join("local"));
|
|
let head = commit(&local, ".gpg-id", b"ALICE\n", "Initialize");
|
|
let user_key = key();
|
|
let server = start_server(
|
|
user_key.public_key().clone(),
|
|
None,
|
|
Some(head.clone()),
|
|
ReceiveBehavior::Success,
|
|
false,
|
|
1,
|
|
);
|
|
let remote = remote(temporary.path(), &server, &user_key, scp_like);
|
|
let mut local = local;
|
|
local.add_remote("origin", remote.url()).expect("remote");
|
|
local
|
|
.push(&remote, Some("main"), &Credentials)
|
|
.expect("current push");
|
|
assert_eq!(tracking_id(&local), Some(head));
|
|
server.join.join().expect("server");
|
|
assert_eq!(
|
|
server.observed.lock().expect("observed").receive_requests,
|
|
[b"0000".to_vec()]
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn receive_pack_failures_never_advance_tracking_or_change_local_state() {
|
|
for (behavior, expected) in [
|
|
(ReceiveBehavior::NonFastForward, GitError::NonFastForward),
|
|
(
|
|
ReceiveBehavior::Reject,
|
|
GitError::RemoteRefRejected {
|
|
diagnostic: "protected branch".to_owned(),
|
|
},
|
|
),
|
|
(
|
|
ReceiveBehavior::UnpackFailure,
|
|
GitError::RemoteUnpackFailed {
|
|
diagnostic: "corrupt pack".to_owned(),
|
|
},
|
|
),
|
|
(
|
|
ReceiveBehavior::MalformedStatus,
|
|
GitError::PushOutcomeUnknown {
|
|
diagnostic: "malformed receive-pack status".to_owned(),
|
|
},
|
|
),
|
|
(
|
|
ReceiveBehavior::EarlyEof,
|
|
GitError::PushOutcomeUnknown {
|
|
diagnostic: "SSH service ended without confirmed status".to_owned(),
|
|
},
|
|
),
|
|
(
|
|
ReceiveBehavior::NonZero,
|
|
GitError::PushOutcomeUnknown {
|
|
diagnostic: "receive-pack failed".to_owned(),
|
|
},
|
|
),
|
|
(
|
|
ReceiveBehavior::Signal,
|
|
GitError::PushOutcomeUnknown {
|
|
diagnostic: "killed".to_owned(),
|
|
},
|
|
),
|
|
(
|
|
ReceiveBehavior::Disconnect,
|
|
GitError::PushOutcomeUnknown {
|
|
diagnostic: "SSH service ended without confirmed status".to_owned(),
|
|
},
|
|
),
|
|
] {
|
|
let temporary = tempfile::tempdir().expect("temporary directory");
|
|
let local = local_repository(&temporary.path().join("local"));
|
|
commit(&local, ".gpg-id", b"ALICE\n", "Initialize");
|
|
let head = commit(&local, "entry.gpg", b"ciphertext", "Add entry");
|
|
let before_status = local.status().expect("status");
|
|
let before_entry = fs::read(local.root().join("entry.gpg")).expect("entry");
|
|
let user_key = key();
|
|
let server = start_server(
|
|
user_key.public_key().clone(),
|
|
None,
|
|
None,
|
|
behavior,
|
|
false,
|
|
1,
|
|
);
|
|
let remote = remote(temporary.path(), &server, &user_key, false);
|
|
let mut local = local;
|
|
local.add_remote("origin", remote.url()).expect("remote");
|
|
assert_eq!(
|
|
local
|
|
.push(&remote, Some("main"), &Credentials)
|
|
.expect_err("push failure"),
|
|
expected
|
|
);
|
|
assert_eq!(tracking_id(&local), None);
|
|
assert_eq!(local.status().expect("status"), before_status);
|
|
assert_eq!(
|
|
fs::read(local.root().join("entry.gpg")).expect("entry"),
|
|
before_entry
|
|
);
|
|
assert_eq!(local.log(Some(1)).expect("log")[0].id(), head);
|
|
server.join.join().expect("server");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn non_fast_forward_and_cancellation_fail_without_blind_replay() {
|
|
let temporary = tempfile::tempdir().expect("temporary directory");
|
|
let local = local_repository(&temporary.path().join("local"));
|
|
commit(&local, ".gpg-id", b"ALICE\n", "Initialize");
|
|
let unrelated = "1111111111111111111111111111111111111111".to_owned();
|
|
let user_key = key();
|
|
let server = start_server(
|
|
user_key.public_key().clone(),
|
|
None,
|
|
Some(unrelated),
|
|
ReceiveBehavior::Success,
|
|
false,
|
|
1,
|
|
);
|
|
let non_ff_remote = remote(temporary.path(), &server, &user_key, false);
|
|
let mut local = local;
|
|
local
|
|
.add_remote("origin", non_ff_remote.url())
|
|
.expect("remote");
|
|
assert_eq!(
|
|
local.push(&non_ff_remote, Some("main"), &Credentials),
|
|
Err(GitError::NonFastForward)
|
|
);
|
|
server.join.join().expect("server");
|
|
assert_eq!(
|
|
server.observed.lock().expect("observed").receive_requests,
|
|
[b"0000".to_vec()]
|
|
);
|
|
|
|
fs::write(local.root().join("staged.gpg"), b"staged").expect("staged entry");
|
|
local.stage(&["staged.gpg".into()]).expect("stage entry");
|
|
let staged = local.status().expect("staged status");
|
|
assert_eq!(
|
|
local.push(&non_ff_remote, Some("main"), &Credentials),
|
|
Err(GitError::DirtyWorktree)
|
|
);
|
|
assert_eq!(local.status().expect("status after refusal"), staged);
|
|
|
|
let control = GitOperationControl::default();
|
|
control.cancel();
|
|
assert_eq!(
|
|
local.push_controlled(&non_ff_remote, Some("main"), &Credentials, &control),
|
|
Err(GitError::Cancelled)
|
|
);
|
|
|
|
let temporary = tempfile::tempdir().expect("temporary directory");
|
|
let local = local_repository(&temporary.path().join("local"));
|
|
commit(&local, ".gpg-id", b"ALICE\n", "Initialize");
|
|
let user_key = key();
|
|
let server = start_server(
|
|
user_key.public_key().clone(),
|
|
None,
|
|
None,
|
|
ReceiveBehavior::SlowSuccess,
|
|
false,
|
|
1,
|
|
);
|
|
let remote = remote(temporary.path(), &server, &user_key, false);
|
|
let mut local = local;
|
|
local.add_remote("origin", remote.url()).expect("remote");
|
|
let control = GitOperationControl::default();
|
|
let cancel = control.clone();
|
|
let cancellation = thread::spawn(move || {
|
|
thread::sleep(Duration::from_millis(100));
|
|
cancel.cancel();
|
|
});
|
|
assert!(matches!(
|
|
local.push_controlled(&remote, Some("main"), &Credentials, &control),
|
|
Err(GitError::PushOutcomeUnknown { .. })
|
|
));
|
|
cancellation.join().expect("cancellation");
|
|
assert_eq!(tracking_id(&local), None);
|
|
server.join.join().expect("server");
|
|
assert_eq!(
|
|
server
|
|
.observed
|
|
.lock()
|
|
.expect("observed")
|
|
.receive_requests
|
|
.len(),
|
|
1
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn untrusted_and_unauthenticated_clients_never_request_receive_pack() {
|
|
let temporary = tempfile::tempdir().expect("temporary directory");
|
|
let local = local_repository(&temporary.path().join("local"));
|
|
commit(&local, ".gpg-id", b"ALICE\n", "Initialize");
|
|
let accepted_identity = key();
|
|
let server = start_server(
|
|
accepted_identity.public_key().clone(),
|
|
None,
|
|
None,
|
|
ReceiveBehavior::Success,
|
|
false,
|
|
2,
|
|
);
|
|
let changed = remote(temporary.path(), &server, &accepted_identity, false);
|
|
fs::write(
|
|
temporary.path().join("known_hosts"),
|
|
format!(
|
|
"[127.0.0.1]:{} {}\n",
|
|
server.port,
|
|
key().public_key().to_openssh().expect("wrong host key")
|
|
),
|
|
)
|
|
.expect("changed known hosts");
|
|
let mut local = local;
|
|
local.add_remote("origin", changed.url()).expect("remote");
|
|
assert!(matches!(
|
|
local.push(&changed, Some("main"), &Credentials),
|
|
Err(GitError::ChangedSshHostKey { .. })
|
|
));
|
|
|
|
let rejected = remote(temporary.path(), &server, &key(), false);
|
|
assert_eq!(
|
|
local.push(&rejected, Some("main"), &Credentials),
|
|
Err(GitError::SshAuthenticationRejected)
|
|
);
|
|
server.join.join().expect("server");
|
|
assert!(
|
|
server
|
|
.observed
|
|
.lock()
|
|
.expect("observed")
|
|
.commands
|
|
.is_empty()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn synchronization_pulls_then_pushes_over_both_ssh_url_forms() {
|
|
for scp_like in [false, true] {
|
|
let temporary = tempfile::tempdir().expect("temporary directory");
|
|
let source = local_repository(&temporary.path().join("source"));
|
|
let base = commit(&source, ".gpg-id", b"ALICE\n", "Initialize");
|
|
let user_key = key();
|
|
let server = start_server(
|
|
user_key.public_key().clone(),
|
|
Some(upload_fixture(&source)),
|
|
Some(base.clone()),
|
|
ReceiveBehavior::Success,
|
|
false,
|
|
3,
|
|
);
|
|
let remote = remote(temporary.path(), &server, &user_key, scp_like);
|
|
let destination = temporary.path().join("clone");
|
|
let clone = GitRepository::clone_into(&destination, identity(), &remote, &Credentials)
|
|
.expect("clone");
|
|
let new = commit(&clone, "local.gpg", b"local", "Local change");
|
|
let (pull, push) = clone.sync(&remote, &Credentials).expect("synchronize");
|
|
assert_eq!(pull, PullOutcome::UpToDate);
|
|
assert_eq!(push.new_id(), new);
|
|
assert_eq!(tracking_id(&clone), Some(new));
|
|
server.join.join().expect("server");
|
|
let observed = server.observed.lock().expect("observed");
|
|
assert_eq!(
|
|
observed
|
|
.commands
|
|
.iter()
|
|
.filter(|command| command.starts_with(b"git-upload-pack"))
|
|
.count(),
|
|
2
|
|
);
|
|
assert_eq!(
|
|
observed
|
|
.commands
|
|
.iter()
|
|
.filter(|command| command.starts_with(b"git-receive-pack"))
|
|
.count(),
|
|
1
|
|
);
|
|
let path = if scp_like {
|
|
"'team/store.git'"
|
|
} else {
|
|
"'/team/store.git'"
|
|
};
|
|
let upload = format!("git-upload-pack {path}").into_bytes();
|
|
let receive = format!("git-receive-pack {path}").into_bytes();
|
|
assert!(
|
|
observed
|
|
.commands
|
|
.iter()
|
|
.all(|command| command == &upload || command == &receive)
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn synchronization_never_pushes_after_pull_failure() {
|
|
let temporary = tempfile::tempdir().expect("temporary directory");
|
|
let local = local_repository(&temporary.path().join("local"));
|
|
commit(&local, ".gpg-id", b"ALICE\n", "Initialize");
|
|
let user_key = key();
|
|
let server = start_server(
|
|
user_key.public_key().clone(),
|
|
None,
|
|
None,
|
|
ReceiveBehavior::Success,
|
|
true,
|
|
1,
|
|
);
|
|
let remote = remote(temporary.path(), &server, &user_key, false);
|
|
let mut local = local;
|
|
local.add_remote("origin", remote.url()).expect("remote");
|
|
assert!(local.sync(&remote, &Credentials).is_err());
|
|
server.join.join().expect("server");
|
|
let commands = &server.observed.lock().expect("observed").commands;
|
|
assert_eq!(commands.len(), 1);
|
|
assert!(commands[0].starts_with(b"git-upload-pack"));
|
|
}
|