chore: initial commit
This commit is contained in:
commit
fae0746382
|
@ -0,0 +1 @@
|
|||
/target
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,22 @@
|
|||
[package]
|
||||
name = "git-vain"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
anyhow = "1"
|
||||
chrono = "0.4"
|
||||
clap = { version = "4", features = ["derive"] }
|
||||
data-encoding = "2"
|
||||
flate2 = "1"
|
||||
git2 = "0.17"
|
||||
gpgme = "0.11"
|
||||
indicatif = "0.17"
|
||||
inquire = "0.6"
|
||||
itoa = "1"
|
||||
num_cpus = "1"
|
||||
rand = "0.8"
|
||||
sequoia-openpgp = { git = "https://gitlab.com/sequoia-pgp/sequoia" }
|
||||
sha1 = "0.10"
|
|
@ -0,0 +1,287 @@
|
|||
EUROPEAN UNION PUBLIC LICENCE v. 1.2
|
||||
EUPL © the European Union 2007, 2016
|
||||
|
||||
This European Union Public Licence (the ‘EUPL’) applies to the Work (as defined
|
||||
below) which is provided under the terms of this Licence. Any use of the Work,
|
||||
other than as authorised under this Licence is prohibited (to the extent such
|
||||
use is covered by a right of the copyright holder of the Work).
|
||||
|
||||
The Work is provided under the terms of this Licence when the Licensor (as
|
||||
defined below) has placed the following notice immediately following the
|
||||
copyright notice for the Work:
|
||||
|
||||
Licensed under the EUPL
|
||||
|
||||
or has expressed by any other means his willingness to license under the EUPL.
|
||||
|
||||
1. Definitions
|
||||
|
||||
In this Licence, the following terms have the following meaning:
|
||||
|
||||
- ‘The Licence’: this Licence.
|
||||
|
||||
- ‘The Original Work’: the work or software distributed or communicated by the
|
||||
Licensor under this Licence, available as Source Code and also as Executable
|
||||
Code as the case may be.
|
||||
|
||||
- ‘Derivative Works’: the works or software that could be created by the
|
||||
Licensee, based upon the Original Work or modifications thereof. This Licence
|
||||
does not define the extent of modification or dependence on the Original Work
|
||||
required in order to classify a work as a Derivative Work; this extent is
|
||||
determined by copyright law applicable in the country mentioned in Article 15.
|
||||
|
||||
- ‘The Work’: the Original Work or its Derivative Works.
|
||||
|
||||
- ‘The Source Code’: the human-readable form of the Work which is the most
|
||||
convenient for people to study and modify.
|
||||
|
||||
- ‘The Executable Code’: any code which has generally been compiled and which is
|
||||
meant to be interpreted by a computer as a program.
|
||||
|
||||
- ‘The Licensor’: the natural or legal person that distributes or communicates
|
||||
the Work under the Licence.
|
||||
|
||||
- ‘Contributor(s)’: any natural or legal person who modifies the Work under the
|
||||
Licence, or otherwise contributes to the creation of a Derivative Work.
|
||||
|
||||
- ‘The Licensee’ or ‘You’: any natural or legal person who makes any usage of
|
||||
the Work under the terms of the Licence.
|
||||
|
||||
- ‘Distribution’ or ‘Communication’: any act of selling, giving, lending,
|
||||
renting, distributing, communicating, transmitting, or otherwise making
|
||||
available, online or offline, copies of the Work or providing access to its
|
||||
essential functionalities at the disposal of any other natural or legal
|
||||
person.
|
||||
|
||||
2. Scope of the rights granted by the Licence
|
||||
|
||||
The Licensor hereby grants You a worldwide, royalty-free, non-exclusive,
|
||||
sublicensable licence to do the following, for the duration of copyright vested
|
||||
in the Original Work:
|
||||
|
||||
- use the Work in any circumstance and for all usage,
|
||||
- reproduce the Work,
|
||||
- modify the Work, and make Derivative Works based upon the Work,
|
||||
- communicate to the public, including the right to make available or display
|
||||
the Work or copies thereof to the public and perform publicly, as the case may
|
||||
be, the Work,
|
||||
- distribute the Work or copies thereof,
|
||||
- lend and rent the Work or copies thereof,
|
||||
- sublicense rights in the Work or copies thereof.
|
||||
|
||||
Those rights can be exercised on any media, supports and formats, whether now
|
||||
known or later invented, as far as the applicable law permits so.
|
||||
|
||||
In the countries where moral rights apply, the Licensor waives his right to
|
||||
exercise his moral right to the extent allowed by law in order to make effective
|
||||
the licence of the economic rights here above listed.
|
||||
|
||||
The Licensor grants to the Licensee royalty-free, non-exclusive usage rights to
|
||||
any patents held by the Licensor, to the extent necessary to make use of the
|
||||
rights granted on the Work under this Licence.
|
||||
|
||||
3. Communication of the Source Code
|
||||
|
||||
The Licensor may provide the Work either in its Source Code form, or as
|
||||
Executable Code. If the Work is provided as Executable Code, the Licensor
|
||||
provides in addition a machine-readable copy of the Source Code of the Work
|
||||
along with each copy of the Work that the Licensor distributes or indicates, in
|
||||
a notice following the copyright notice attached to the Work, a repository where
|
||||
the Source Code is easily and freely accessible for as long as the Licensor
|
||||
continues to distribute or communicate the Work.
|
||||
|
||||
4. Limitations on copyright
|
||||
|
||||
Nothing in this Licence is intended to deprive the Licensee of the benefits from
|
||||
any exception or limitation to the exclusive rights of the rights owners in the
|
||||
Work, of the exhaustion of those rights or of other applicable limitations
|
||||
thereto.
|
||||
|
||||
5. Obligations of the Licensee
|
||||
|
||||
The grant of the rights mentioned above is subject to some restrictions and
|
||||
obligations imposed on the Licensee. Those obligations are the following:
|
||||
|
||||
Attribution right: The Licensee shall keep intact all copyright, patent or
|
||||
trademarks notices and all notices that refer to the Licence and to the
|
||||
disclaimer of warranties. The Licensee must include a copy of such notices and a
|
||||
copy of the Licence with every copy of the Work he/she distributes or
|
||||
communicates. The Licensee must cause any Derivative Work to carry prominent
|
||||
notices stating that the Work has been modified and the date of modification.
|
||||
|
||||
Copyleft clause: If the Licensee distributes or communicates copies of the
|
||||
Original Works or Derivative Works, this Distribution or Communication will be
|
||||
done under the terms of this Licence or of a later version of this Licence
|
||||
unless the Original Work is expressly distributed only under this version of the
|
||||
Licence — for example by communicating ‘EUPL v. 1.2 only’. The Licensee
|
||||
(becoming Licensor) cannot offer or impose any additional terms or conditions on
|
||||
the Work or Derivative Work that alter or restrict the terms of the Licence.
|
||||
|
||||
Compatibility clause: If the Licensee Distributes or Communicates Derivative
|
||||
Works or copies thereof based upon both the Work and another work licensed under
|
||||
a Compatible Licence, this Distribution or Communication can be done under the
|
||||
terms of this Compatible Licence. For the sake of this clause, ‘Compatible
|
||||
Licence’ refers to the licences listed in the appendix attached to this Licence.
|
||||
Should the Licensee's obligations under the Compatible Licence conflict with
|
||||
his/her obligations under this Licence, the obligations of the Compatible
|
||||
Licence shall prevail.
|
||||
|
||||
Provision of Source Code: When distributing or communicating copies of the Work,
|
||||
the Licensee will provide a machine-readable copy of the Source Code or indicate
|
||||
a repository where this Source will be easily and freely available for as long
|
||||
as the Licensee continues to distribute or communicate the Work.
|
||||
|
||||
Legal Protection: This Licence does not grant permission to use the trade names,
|
||||
trademarks, service marks, or names of the Licensor, except as required for
|
||||
reasonable and customary use in describing the origin of the Work and
|
||||
reproducing the content of the copyright notice.
|
||||
|
||||
6. Chain of Authorship
|
||||
|
||||
The original Licensor warrants that the copyright in the Original Work granted
|
||||
hereunder is owned by him/her or licensed to him/her and that he/she has the
|
||||
power and authority to grant the Licence.
|
||||
|
||||
Each Contributor warrants that the copyright in the modifications he/she brings
|
||||
to the Work are owned by him/her or licensed to him/her and that he/she has the
|
||||
power and authority to grant the Licence.
|
||||
|
||||
Each time You accept the Licence, the original Licensor and subsequent
|
||||
Contributors grant You a licence to their contributions to the Work, under the
|
||||
terms of this Licence.
|
||||
|
||||
7. Disclaimer of Warranty
|
||||
|
||||
The Work is a work in progress, which is continuously improved by numerous
|
||||
Contributors. It is not a finished work and may therefore contain defects or
|
||||
‘bugs’ inherent to this type of development.
|
||||
|
||||
For the above reason, the Work is provided under the Licence on an ‘as is’ basis
|
||||
and without warranties of any kind concerning the Work, including without
|
||||
limitation merchantability, fitness for a particular purpose, absence of defects
|
||||
or errors, accuracy, non-infringement of intellectual property rights other than
|
||||
copyright as stated in Article 6 of this Licence.
|
||||
|
||||
This disclaimer of warranty is an essential part of the Licence and a condition
|
||||
for the grant of any rights to the Work.
|
||||
|
||||
8. Disclaimer of Liability
|
||||
|
||||
Except in the cases of wilful misconduct or damages directly caused to natural
|
||||
persons, the Licensor will in no event be liable for any direct or indirect,
|
||||
material or moral, damages of any kind, arising out of the Licence or of the use
|
||||
of the Work, including without limitation, damages for loss of goodwill, work
|
||||
stoppage, computer failure or malfunction, loss of data or any commercial
|
||||
damage, even if the Licensor has been advised of the possibility of such damage.
|
||||
However, the Licensor will be liable under statutory product liability laws as
|
||||
far such laws apply to the Work.
|
||||
|
||||
9. Additional agreements
|
||||
|
||||
While distributing the Work, You may choose to conclude an additional agreement,
|
||||
defining obligations or services consistent with this Licence. However, if
|
||||
accepting obligations, You may act only on your own behalf and on your sole
|
||||
responsibility, not on behalf of the original Licensor or any other Contributor,
|
||||
and only if You agree to indemnify, defend, and hold each Contributor harmless
|
||||
for any liability incurred by, or claims asserted against such Contributor by
|
||||
the fact You have accepted any warranty or additional liability.
|
||||
|
||||
10. Acceptance of the Licence
|
||||
|
||||
The provisions of this Licence can be accepted by clicking on an icon ‘I agree’
|
||||
placed under the bottom of a window displaying the text of this Licence or by
|
||||
affirming consent in any other similar way, in accordance with the rules of
|
||||
applicable law. Clicking on that icon indicates your clear and irrevocable
|
||||
acceptance of this Licence and all of its terms and conditions.
|
||||
|
||||
Similarly, you irrevocably accept this Licence and all of its terms and
|
||||
conditions by exercising any rights granted to You by Article 2 of this Licence,
|
||||
such as the use of the Work, the creation by You of a Derivative Work or the
|
||||
Distribution or Communication by You of the Work or copies thereof.
|
||||
|
||||
11. Information to the public
|
||||
|
||||
In case of any Distribution or Communication of the Work by means of electronic
|
||||
communication by You (for example, by offering to download the Work from a
|
||||
remote location) the distribution channel or media (for example, a website) must
|
||||
at least provide to the public the information requested by the applicable law
|
||||
regarding the Licensor, the Licence and the way it may be accessible, concluded,
|
||||
stored and reproduced by the Licensee.
|
||||
|
||||
12. Termination of the Licence
|
||||
|
||||
The Licence and the rights granted hereunder will terminate automatically upon
|
||||
any breach by the Licensee of the terms of the Licence.
|
||||
|
||||
Such a termination will not terminate the licences of any person who has
|
||||
received the Work from the Licensee under the Licence, provided such persons
|
||||
remain in full compliance with the Licence.
|
||||
|
||||
13. Miscellaneous
|
||||
|
||||
Without prejudice of Article 9 above, the Licence represents the complete
|
||||
agreement between the Parties as to the Work.
|
||||
|
||||
If any provision of the Licence is invalid or unenforceable under applicable
|
||||
law, this will not affect the validity or enforceability of the Licence as a
|
||||
whole. Such provision will be construed or reformed so as necessary to make it
|
||||
valid and enforceable.
|
||||
|
||||
The European Commission may publish other linguistic versions or new versions of
|
||||
this Licence or updated versions of the Appendix, so far this is required and
|
||||
reasonable, without reducing the scope of the rights granted by the Licence. New
|
||||
versions of the Licence will be published with a unique version number.
|
||||
|
||||
All linguistic versions of this Licence, approved by the European Commission,
|
||||
have identical value. Parties can take advantage of the linguistic version of
|
||||
their choice.
|
||||
|
||||
14. Jurisdiction
|
||||
|
||||
Without prejudice to specific agreement between parties,
|
||||
|
||||
- any litigation resulting from the interpretation of this License, arising
|
||||
between the European Union institutions, bodies, offices or agencies, as a
|
||||
Licensor, and any Licensee, will be subject to the jurisdiction of the Court
|
||||
of Justice of the European Union, as laid down in article 272 of the Treaty on
|
||||
the Functioning of the European Union,
|
||||
|
||||
- any litigation arising between other parties and resulting from the
|
||||
interpretation of this License, will be subject to the exclusive jurisdiction
|
||||
of the competent court where the Licensor resides or conducts its primary
|
||||
business.
|
||||
|
||||
15. Applicable Law
|
||||
|
||||
Without prejudice to specific agreement between parties,
|
||||
|
||||
- this Licence shall be governed by the law of the European Union Member State
|
||||
where the Licensor has his seat, resides or has his registered office,
|
||||
|
||||
- this licence shall be governed by Belgian law if the Licensor has no seat,
|
||||
residence or registered office inside a European Union Member State.
|
||||
|
||||
Appendix
|
||||
|
||||
‘Compatible Licences’ according to Article 5 EUPL are:
|
||||
|
||||
- GNU General Public License (GPL) v. 2, v. 3
|
||||
- GNU Affero General Public License (AGPL) v. 3
|
||||
- Open Software License (OSL) v. 2.1, v. 3.0
|
||||
- Eclipse Public License (EPL) v. 1.0
|
||||
- CeCILL v. 2.0, v. 2.1
|
||||
- Mozilla Public Licence (MPL) v. 2
|
||||
- GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3
|
||||
- Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for
|
||||
works other than software
|
||||
- European Union Public Licence (EUPL) v. 1.1, v. 1.2
|
||||
- Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or Strong
|
||||
Reciprocity (LiLiQ-R+).
|
||||
|
||||
The European Commission may update this Appendix to later versions of the above
|
||||
licences without producing a new version of the EUPL, as long as they provide
|
||||
the rights granted in Article 2 of this Licence and protect the covered Source
|
||||
Code from exclusive appropriation.
|
||||
|
||||
All other changes or additions to this Appendix require the production of a new
|
||||
EUPL version.
|
|
@ -0,0 +1,9 @@
|
|||
# git-vain
|
||||
|
||||
Generate vanity commit hashes quickly.
|
||||
|
||||
Supports:
|
||||
- pgp signing (via gpg-agent or sequoia)
|
||||
- arbitrary commits from history
|
||||
- various methods (date increment/decrement, random text, counter text)
|
||||
- multithreading
|
|
@ -0,0 +1,434 @@
|
|||
use std::borrow::Cow;
|
||||
use std::fs::File;
|
||||
use std::io::Write;
|
||||
use std::process::Command;
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicBool, AtomicI64, AtomicUsize, Ordering};
|
||||
|
||||
use anyhow::{Context as _, Result};
|
||||
use clap::{Parser, ValueEnum};
|
||||
use flate2::Compression;
|
||||
use flate2::write::ZlibEncoder;
|
||||
use git2::Repository;
|
||||
use gpgme::{Context, Protocol, SignMode};
|
||||
use indicatif::ProgressStyle;
|
||||
use openpgp::{
|
||||
packet::prelude::*,
|
||||
parse::Parse,
|
||||
serialize::{
|
||||
Serialize,
|
||||
stream::{Armorer, Message},
|
||||
},
|
||||
types::*,
|
||||
};
|
||||
use rand::Rng;
|
||||
use sequoia_openpgp as openpgp;
|
||||
use sequoia_openpgp::policy::StandardPolicy;
|
||||
use sha1::{Digest, Sha1};
|
||||
|
||||
/// A vanity commit hash generator that's fast, works with PGP signing, and can
|
||||
/// be used on arbitrary commits (not just HEAD).
|
||||
///
|
||||
/// This works by decrementing the commit time one second and recalculating the
|
||||
/// hash until a hash matching your selected prefix is found.
|
||||
///
|
||||
/// If using PGP signing, the timestamp remains unchanged. Every PGP signature is different, even on
|
||||
/// the same data, so decrementing the timestamp is no longer required.
|
||||
/// Providing a key file is orders of magnitude faster than providing a key ID,
|
||||
/// since using a key ID goes through gpg-agent, which is very slow.
|
||||
#[derive(Parser)]
|
||||
struct Cli {
|
||||
/// The commit to replace with a vanity hash. Defaults to HEAD.
|
||||
#[arg(short, long)]
|
||||
commit: Option<String>,
|
||||
|
||||
/// The key ID to use for signing.
|
||||
///
|
||||
/// This is very slow compared to providing a key file, but this will use
|
||||
/// gpg-agent.
|
||||
#[arg(short = 'k', long)]
|
||||
signing_key: Option<String>,
|
||||
|
||||
/// Path to an export secret key to use for signing. This is orders of
|
||||
/// magnitude faster than providing a key ID, but it will not use gpg-agent
|
||||
/// and requires you to provide your password to git-vain.
|
||||
#[arg(short = 'K', long)]
|
||||
signing_key_file: Option<String>,
|
||||
|
||||
/// The number of threads to use when searching for a matching hash.
|
||||
/// Defaults to 0, and 0 will use the number of logical cores on your
|
||||
/// system.
|
||||
#[arg(short, long)]
|
||||
threads: Option<usize>,
|
||||
|
||||
/// The method of changing the commit to generate a new hash. Defaults to
|
||||
/// decrement.
|
||||
///
|
||||
/// Note that this has no effect if a signing key is provided.
|
||||
///
|
||||
/// - decrement will decrease the commit date by one second for each attempt
|
||||
///
|
||||
/// - increment will increase the commit date by one second for each attempt
|
||||
///
|
||||
/// - random will append a random string to the commit message for each
|
||||
/// attempt
|
||||
///
|
||||
/// - counter will append an increasing number to the commit message for
|
||||
/// each attempt
|
||||
#[arg(short, long, value_enum, default_value_t = Method::Decrement)]
|
||||
method: Method,
|
||||
|
||||
/// Force generating a new vanity hash for commits that already start with
|
||||
/// the requested prefix.
|
||||
#[arg(short, long)]
|
||||
force: bool,
|
||||
|
||||
/// The vanity commit hash prefix you desire.
|
||||
prefix: String,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
|
||||
enum Method {
|
||||
Decrement,
|
||||
Increment,
|
||||
Random,
|
||||
Counter,
|
||||
}
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let args = Cli::parse();
|
||||
|
||||
if args.signing_key.is_some() && args.signing_key_file.is_some() {
|
||||
anyhow::bail!("specify a key id or key file, not both");
|
||||
}
|
||||
|
||||
let prefix = args.prefix.to_lowercase();
|
||||
let commit = args.commit.as_deref().unwrap_or("HEAD");
|
||||
let threads = match args.threads.unwrap_or(0) {
|
||||
0 => num_cpus::get(),
|
||||
x => x,
|
||||
};
|
||||
|
||||
let mut seq_key = None;
|
||||
if let Some(path) = &args.signing_key_file {
|
||||
let key = openpgp::Cert::from_file(path)
|
||||
.context("failed to read key from file")?;
|
||||
|
||||
let mut keys = Vec::new();
|
||||
let p = &StandardPolicy::new();
|
||||
for key in key
|
||||
.keys().with_policy(p, None).alive().revoked(false).for_signing().secret()
|
||||
.map(|ka| ka.key())
|
||||
{
|
||||
let key = if key.has_unencrypted_secret() {
|
||||
key.clone().into_keypair()
|
||||
.context("failed to convert unencrypted key into keypair")?
|
||||
} else {
|
||||
let mut first = true;
|
||||
loop {
|
||||
let mut prompt = inquire::Password::new("Key password: ");
|
||||
if !first {
|
||||
prompt = prompt.with_help_message("Failed to decrypt the secret key with that password");
|
||||
}
|
||||
|
||||
let password = prompt.without_confirmation()
|
||||
.prompt()?;
|
||||
let decrypted = key.clone()
|
||||
.decrypt_secret(&password.trim().into())
|
||||
.context("failed to decrypt secret key");
|
||||
first = false;
|
||||
|
||||
match decrypted {
|
||||
Ok(d) => break d.into_keypair()
|
||||
.context("failed to convert decrypted key into keypair")?,
|
||||
Err(_) => continue,
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
keys.push(key);
|
||||
}
|
||||
|
||||
if keys.is_empty() {
|
||||
anyhow::bail!("no suitable signing keys in key file");
|
||||
}
|
||||
|
||||
seq_key = keys.pop();
|
||||
}
|
||||
|
||||
// first open the repo and find the commit pointed to by HEAD
|
||||
let repo = Repository::open(".")
|
||||
.context("no git repository in this directory")?;
|
||||
|
||||
let obj = repo.revparse_single(commit)
|
||||
.context("could not find reference")?;
|
||||
let commit = repo.find_commit(obj.id())
|
||||
.context("could not resolve reference to a commit")?;
|
||||
|
||||
if !args.force && commit.id().to_string().starts_with(&prefix) {
|
||||
anyhow::bail!("commit already starts with prefix");
|
||||
}
|
||||
|
||||
// grab the header of the commit and the message
|
||||
let raw_header = commit.raw_header()
|
||||
.context("commit had an invalid header")?;
|
||||
|
||||
let mut header_lines = Vec::default();
|
||||
// strip out the signature lines
|
||||
{
|
||||
let mut in_sig = false;
|
||||
for line in raw_header.split('\n') {
|
||||
if line.starts_with("gpgsig ") {
|
||||
in_sig = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
if in_sig {
|
||||
if line.starts_with(' ') {
|
||||
continue;
|
||||
} else {
|
||||
in_sig = false;
|
||||
}
|
||||
}
|
||||
|
||||
header_lines.push(line.to_string());
|
||||
}
|
||||
}
|
||||
|
||||
let message = commit.message_raw()
|
||||
.context("commit had an invalid message")?
|
||||
.to_string();
|
||||
|
||||
// find the author and committer
|
||||
let author_idx = header_lines.iter()
|
||||
.position(|line| line.starts_with("author "))
|
||||
.context("missing author")?;
|
||||
let committer_idx = header_lines.iter()
|
||||
.position(|line| line.starts_with("committer "))
|
||||
.context("missing committer")?;
|
||||
|
||||
// split the lines by spaces
|
||||
let author_parts: Vec<_> = header_lines[author_idx].split(' ')
|
||||
.map(ToOwned::to_owned)
|
||||
.collect();
|
||||
let committer_parts: Vec<_> = header_lines[committer_idx].split(' ')
|
||||
.map(ToOwned::to_owned)
|
||||
.collect();
|
||||
// get the timestamp
|
||||
let timestamp = author_parts.get(author_parts.len() - 2)
|
||||
.context("missing timestamp")?
|
||||
.parse::<i64>()
|
||||
.context("invalid timestamp")?;
|
||||
// let original = timestamp;
|
||||
|
||||
let author_len = author_parts.len();
|
||||
let committer_len = committer_parts.len();
|
||||
|
||||
let counter = Arc::new(AtomicUsize::default());
|
||||
let found = Arc::new(AtomicBool::new(false));
|
||||
let timestamp = Arc::new(AtomicI64::new(timestamp));
|
||||
let (commit_tx, commit_rx) = std::sync::mpsc::channel();
|
||||
|
||||
let bar = indicatif::ProgressBar::new_spinner()
|
||||
.with_style(ProgressStyle::with_template("{spinner} {elapsed} - {human_len} hashes ({per_sec})")?);
|
||||
|
||||
for _ in 0..threads {
|
||||
let bar = bar.clone();
|
||||
let mut seq_key = seq_key.clone();
|
||||
let key = args.signing_key.clone();
|
||||
let counter = Arc::clone(&counter);
|
||||
let found = Arc::clone(&found);
|
||||
let timestamp = Arc::clone(×tamp);
|
||||
let message = message.clone();
|
||||
let prefix = prefix.clone();
|
||||
let mut author_parts = author_parts.clone();
|
||||
let mut committer_parts = committer_parts.clone();
|
||||
let mut header_lines = header_lines.clone();
|
||||
let method = args.method;
|
||||
let commit_tx = commit_tx.clone();
|
||||
|
||||
std::thread::spawn(move || {
|
||||
let mut gpg = match key {
|
||||
Some(key) => {
|
||||
let mut ctx = Context::from_protocol(Protocol::OpenPgp)
|
||||
.context("could not create openpgp context")
|
||||
.unwrap(); // FIXME
|
||||
ctx.set_armor(true);
|
||||
let key = ctx.get_secret_key(key)
|
||||
.context("could not find secret key")
|
||||
.unwrap(); // FIXME
|
||||
ctx.add_signer(&key)
|
||||
.context("could not add signer")
|
||||
.unwrap(); // FIXME
|
||||
Some((ctx, key))
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
|
||||
let mut sha1 = Sha1::default();
|
||||
loop {
|
||||
if found.load(Ordering::SeqCst) {
|
||||
break;
|
||||
}
|
||||
|
||||
let timestamp = if gpg.is_some() || seq_key.is_some() {
|
||||
timestamp.load(Ordering::SeqCst)
|
||||
} else {
|
||||
match method {
|
||||
Method::Decrement => timestamp.fetch_sub(1, Ordering::SeqCst) - 1,
|
||||
Method::Increment => timestamp.fetch_add(1, Ordering::SeqCst) + 1,
|
||||
_ => timestamp.load(Ordering::SeqCst),
|
||||
}
|
||||
};
|
||||
|
||||
let mut buffer = itoa::Buffer::new();
|
||||
let append = if gpg.is_some() || seq_key.is_some() {
|
||||
None
|
||||
} else {
|
||||
match method {
|
||||
Method::Random => {
|
||||
let mut bytes = [0; 16];
|
||||
rand::thread_rng().fill(&mut bytes);
|
||||
Some(data_encoding::HEXLOWER.encode(&bytes))
|
||||
}
|
||||
Method::Counter => {
|
||||
let count = counter.fetch_add(1, Ordering::SeqCst) + 1;
|
||||
Some(buffer.format(count).to_owned())
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
};
|
||||
|
||||
author_parts[author_len - 2] = buffer.format(timestamp).to_owned();
|
||||
committer_parts[committer_len - 2] = buffer.format(timestamp).to_owned();
|
||||
|
||||
header_lines[author_idx] = author_parts.join(" ");
|
||||
header_lines[committer_idx] = committer_parts.join(" ");
|
||||
|
||||
let mut header = header_lines.join("\n");
|
||||
|
||||
if let Some((ctx, _)) = &mut gpg {
|
||||
let to_sign = format!("{header}\n{message}");
|
||||
let mut output = Vec::new();
|
||||
ctx.sign(SignMode::Detached, to_sign, &mut output)
|
||||
.context("could not sign commit")
|
||||
.unwrap(); // FIXME
|
||||
|
||||
let sig = String::from_utf8(output)
|
||||
.context("signature was not utf-8")
|
||||
.unwrap(); // FIXME
|
||||
header.push_str("gpgsig");
|
||||
for line in sig.trim().split('\n') {
|
||||
header.push(' ');
|
||||
header.push_str(line);
|
||||
header.push('\n');
|
||||
}
|
||||
} else if let Some(key) = &mut seq_key {
|
||||
let to_sign = format!("{header}\n{message}");
|
||||
let sig = SignatureBuilder::new(SignatureType::Binary)
|
||||
.sign_message(key, to_sign)
|
||||
.context("failed to sign message")
|
||||
.unwrap(); // FIXME
|
||||
|
||||
let mut output = Vec::new();
|
||||
let message = Message::new(&mut output);
|
||||
let mut message = Armorer::new(message)
|
||||
.kind(openpgp::armor::Kind::Signature)
|
||||
.build()
|
||||
.context("failed to build pgp message")
|
||||
.unwrap(); // FIXME
|
||||
Packet::from(sig)
|
||||
.serialize(&mut message)
|
||||
.context("failed to serialise packet")
|
||||
.unwrap(); // FIXME
|
||||
message.finalize()
|
||||
.context("could not finalise message")
|
||||
.unwrap(); // FIXME
|
||||
|
||||
let sig = String::from_utf8(output)
|
||||
.context("signature was not utf-8")
|
||||
.unwrap(); // FIXME
|
||||
header.push_str("gpgsig");
|
||||
for line in sig.trim().split('\n') {
|
||||
header.push(' ');
|
||||
header.push_str(line);
|
||||
header.push('\n');
|
||||
}
|
||||
}
|
||||
|
||||
let message = match append {
|
||||
Some(append) => Cow::from(format!("{message}\n{append}\n")),
|
||||
None => Cow::from(&message),
|
||||
};
|
||||
|
||||
let total = format!("{header}\n{message}");
|
||||
let raw_commit = format!("commit {}\0", total.len());
|
||||
sha1.update(&raw_commit);
|
||||
sha1.update(&total);
|
||||
let hash = sha1.finalize_reset();
|
||||
let hash = data_encoding::HEXLOWER.encode(&hash);
|
||||
|
||||
bar.inc(1);
|
||||
if hash.starts_with(&prefix) {
|
||||
found.store(true, Ordering::SeqCst);
|
||||
commit_tx.send((hash, format!("{raw_commit}{total}"))).unwrap();
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
let (hash, new_commit_data) = commit_rx.recv().unwrap();
|
||||
bar.finish_and_clear();
|
||||
let path = repo.path();
|
||||
// let old_commit_id = commit.id().to_string();
|
||||
|
||||
// let old_path = path.join("objects")
|
||||
// .join(&old_commit_id[..2])
|
||||
// .join(&old_commit_id[2..]);
|
||||
let new_path = path.join("objects")
|
||||
.join(&hash[..2])
|
||||
.join(&hash[2..]);
|
||||
|
||||
{
|
||||
std::fs::create_dir_all(new_path.parent().unwrap())
|
||||
.context("could not create directory")?;
|
||||
let file = File::create(new_path)
|
||||
.context("could not create commit file")?;
|
||||
let mut compressor = ZlibEncoder::new(file, Compression::fast());
|
||||
compressor.write_all(new_commit_data.as_bytes())
|
||||
.context("could not write commit")?;
|
||||
}
|
||||
|
||||
// let new_commit = repo.find_annotated_commit(Oid::from_str(&hash)?)
|
||||
// .context("cannot get new commit")?;
|
||||
// let new_new_commit = repo.find_commit(Oid::from_str(&hash)?)
|
||||
// .context("cannot get new commit (2)")?;
|
||||
// let old_commit = repo.revparse_single(&format!("{}~1", commit.id()))
|
||||
// .context("cannot find old commit")?;
|
||||
// let old_commit = repo.find_annotated_commit(old_commit.id())
|
||||
// .context("cannot get new commit")?;
|
||||
// let mut rebase = repo.rebase(None, Some(&old_commit), Some(&new_commit), None)?;
|
||||
// while let Some(op) = rebase.next() {
|
||||
// op?;
|
||||
// rebase.commit(None, &new_new_commit.committer(), None)?;
|
||||
// }
|
||||
// rebase.finish(None)?;
|
||||
let previous = format!("{}~1", commit.id());
|
||||
let is_root = repo.revparse_single(&previous).is_err();
|
||||
let final_arg = if is_root {
|
||||
"--root"
|
||||
} else {
|
||||
&*previous
|
||||
};
|
||||
|
||||
Command::new("git")
|
||||
.args(["rebase", "--onto", &hash, final_arg])
|
||||
.spawn()
|
||||
.context("could not spawn rebase command")?
|
||||
.wait()
|
||||
.context("rebase command failed")?;
|
||||
eprintln!("{hash}");
|
||||
|
||||
Ok(())
|
||||
}
|
Loading…
Reference in New Issue