use anyhow::{anyhow, Result};
use base64::engine::general_purpose::STANDARD;
use base64::Engine;
use rand::rngs::OsRng;
use rsa::pkcs1v15::SigningKey;
use rsa::pkcs1v15::VerifyingKey;
use rsa::pkcs8::DecodePrivateKey;
use rsa::pkcs8::EncodePrivateKey;
use rsa::sha2::Sha256;
use rsa::signature::Keypair;
use rsa::signature::SignatureEncoding;
use rsa::signature::Signer;
use rsa::signature::Verifier;
use sha2::Digest;
use spki::{DecodePublicKey, EncodePublicKey};
use std::collections::BTreeMap;
use std::io::{Cursor, Read, Write};
use zip::ZipArchive;
use cms::cert::{CertificateChoices, IssuerAndSerialNumber};
use cms::content_info::{CmsVersion, ContentInfo};
use cms::signed_data::{
CertificateSet, EncapsulatedContentInfo, SignedData, SignerIdentifier, SignerInfo, SignerInfos,
};
use const_oid::ObjectIdentifier;
use der::asn1::{Null, OctetString, SetOfVec, UtcTime};
use der::{Any, Decode, Encode};
use rsa::pkcs1v15::Signature;
use spki::{AlgorithmIdentifierOwned, SubjectPublicKeyInfoOwned};
use std::str::FromStr;
use std::time::Duration;
use x509_cert::builder::{Builder, CertificateBuilder, Profile};
use x509_cert::name::Name;
use x509_cert::serial_number::SerialNumber;
use x509_cert::time::{Time, Validity};
const OID_SIGNED_DATA: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.7.2");
const OID_DATA: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.7.1");
const OID_SHA256: ObjectIdentifier = ObjectIdentifier::new_unwrap("2.16.840.1.101.3.4.2.1");
const OID_RSA: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.1.1");
fn fold_header(key: &str, value: &str) -> String {
let full = format!("{key}: {value}");
let bytes = full.as_bytes();
let mut out = String::new();
let mut start = 0usize;
let mut limit = 72usize;
while bytes.len() - start > limit {
let mut end = start + limit;
while end > start && (bytes[end] & 0xC0) == 0x80 {
end -= 1;
}
out.push_str(std::str::from_utf8(&bytes[start..end]).unwrap_or(""));
out.push_str("\r\n ");
start = end;
limit = 71;
}
out.push_str(std::str::from_utf8(&bytes[start..]).unwrap_or(""));
out.push_str("\r\n");
out
}
fn build_signature_block(signing_key: &SigningKey<Sha256>, sf_bytes: &[u8]) -> Result<Vec<u8>> {
let verifying_key = signing_key.verifying_key();
let spki = SubjectPublicKeyInfoOwned::from_key(verifying_key)
.map_err(|e| anyhow!("Failed to encode public key: {}", e))?;
let subject = Name::from_str("CN=Kojacoord Mod Signing,O=Kojacoord Network")
.map_err(|e| anyhow!("Failed to build subject name: {}", e))?;
let validity = Validity {
not_before: Time::UtcTime(
UtcTime::from_unix_duration(Duration::from_secs(1_577_836_800))
.map_err(|e| anyhow!("not_before: {}", e))?,
),
not_after: Time::UtcTime(
UtcTime::from_unix_duration(Duration::from_secs(2_524_521_600))
.map_err(|e| anyhow!("not_after: {}", e))?,
),
};
let builder = CertificateBuilder::new(
Profile::Manual { issuer: None }, SerialNumber::from(1u32),
validity,
subject,
spki,
signing_key,
)
.map_err(|e| anyhow!("Failed to create certificate builder: {}", e))?;
let cert = builder
.build::<Signature>()
.map_err(|e| anyhow!("Failed to build certificate: {}", e))?;
let signature = signing_key.sign(sf_bytes);
let sig_bytes = signature.to_vec();
let sha256_ai = AlgorithmIdentifierOwned {
oid: OID_SHA256,
parameters: None,
};
let rsa_ai = AlgorithmIdentifierOwned {
oid: OID_RSA,
parameters: Some(Any::encode_from(&Null).map_err(|e| anyhow!("null params: {}", e))?),
};
let signer_info = SignerInfo {
version: CmsVersion::V1,
sid: SignerIdentifier::IssuerAndSerialNumber(IssuerAndSerialNumber {
issuer: cert.tbs_certificate.issuer.clone(),
serial_number: cert.tbs_certificate.serial_number.clone(),
}),
digest_alg: sha256_ai.clone(),
signed_attrs: None,
signature_algorithm: rsa_ai,
signature: OctetString::new(sig_bytes).map_err(|e| anyhow!("signature octet: {}", e))?,
unsigned_attrs: None,
};
let signed_data = SignedData {
version: CmsVersion::V1,
digest_algorithms: SetOfVec::try_from(vec![sha256_ai])
.map_err(|e| anyhow!("digest algorithms: {}", e))?,
encap_content_info: EncapsulatedContentInfo {
econtent_type: OID_DATA,
econtent: None, },
certificates: Some(CertificateSet(
SetOfVec::try_from(vec![CertificateChoices::Certificate(cert)])
.map_err(|e| anyhow!("certificate set: {}", e))?,
)),
crls: None,
signer_infos: SignerInfos(
SetOfVec::try_from(vec![signer_info]).map_err(|e| anyhow!("signer infos: {}", e))?,
),
};
let content_info = ContentInfo {
content_type: OID_SIGNED_DATA,
content: Any::encode_from(&signed_data).map_err(|e| anyhow!("wrap SignedData: {}", e))?,
};
content_info
.to_der()
.map_err(|e| anyhow!("encode ContentInfo: {}", e))
}
pub fn sign_bytes(
jar_bytes: &[u8],
key_bytes: &[u8],
_pass: &str,
override_signature: bool,
) -> Result<Vec<u8>> {
sign_bytes_with_cert_chain(
jar_bytes,
key_bytes,
None,
_pass,
override_signature,
&mut |_, _| {},
)
}
pub fn sign_bytes_with_cert_chain<F>(
jar_bytes: &[u8],
key_bytes: &[u8],
_cert_chain: Option<&[Vec<u8>]>,
_pass: &str,
override_signature: bool,
mut progress_callback: F,
) -> Result<Vec<u8>>
where
F: FnMut(String, bool),
{
let signing_key = SigningKey::<Sha256>::from_pkcs8_der(key_bytes)
.map_err(|e| anyhow!("Failed to parse RSA key: {}", e))?;
let cursor = Cursor::new(jar_bytes);
let mut zip =
ZipArchive::new(cursor).map_err(|e| anyhow!("Failed to open JAR as ZIP: {}", e))?;
let mut preserved_main_attrs: Vec<(String, String)> = Vec::new();
if let Ok(mut mf) = zip.by_name("META-INF/MANIFEST.MF") {
let mut buf = String::new();
if mf.read_to_string(&mut buf).is_ok() {
let main_section_end = buf.find("\r\n\r\n").or_else(|| buf.find("\n\n")).unwrap_or(buf.len());
let main_section = &buf[..main_section_end];
let mut logical: Vec<String> = Vec::new();
for raw in main_section.split('\n') {
let line = raw.trim_end_matches('\r');
if line.starts_with(' ') {
if let Some(last) = logical.last_mut() {
last.push_str(&line[1..]);
continue;
}
}
logical.push(line.to_string());
}
for line in &logical {
if let Some((k, v)) = line.split_once(": ") {
if k.eq_ignore_ascii_case("Manifest-Version") || k.eq_ignore_ascii_case("Created-By") {
continue;
}
preserved_main_attrs.push((k.to_string(), v.to_string()));
}
}
}
}
let mut file_digests = BTreeMap::new();
for i in 0..zip.len() {
let mut file = zip
.by_index(i)
.map_err(|e| anyhow!("Failed to get file {}: {}", i, e))?;
let name = file.name().to_string();
if name.starts_with("META-INF/") {
continue;
}
if name.ends_with('/') {
continue;
}
let mut content = Vec::new();
file.read_to_end(&mut content)
.map_err(|e| anyhow!("Failed to read file {}: {}", name, e))?;
let mut hasher = Sha256::new();
hasher.update(&content);
let digest = STANDARD.encode(hasher.finalize());
file_digests.insert(name, digest);
}
let mut manifest = String::new();
manifest.push_str(&fold_header("Manifest-Version", "1.0"));
manifest.push_str(&fold_header("Created-By", "jarsigned"));
for (k, v) in &preserved_main_attrs {
manifest.push_str(&fold_header(k, v));
}
manifest.push_str("\r\n");
let mut sf_section_digests: Vec<(String, String)> = Vec::new();
for (name, digest) in &file_digests {
let section = format!(
"{}{}\r\n",
fold_header("Name", name),
fold_header("SHA-256-Digest", digest)
);
let mut section_hasher = Sha256::new();
section_hasher.update(section.as_bytes());
sf_section_digests.push((name.clone(), STANDARD.encode(section_hasher.finalize())));
manifest.push_str(§ion);
}
let manifest_bytes = manifest.as_bytes();
let mut manifest_hasher = Sha256::new();
manifest_hasher.update(manifest_bytes);
let manifest_digest = manifest_hasher.finalize();
let mut sf_content = String::new();
sf_content.push_str(&fold_header("Signature-Version", "1.0"));
sf_content.push_str(&fold_header("Created-By", "jarsigned"));
sf_content.push_str(&fold_header(
"SHA-256-Digest-Manifest",
&STANDARD.encode(manifest_digest),
));
sf_content.push_str("\r\n");
for (name, section_digest) in &sf_section_digests {
sf_content.push_str(&fold_header("Name", name));
sf_content.push_str(&fold_header("SHA-256-Digest", section_digest));
sf_content.push_str("\r\n");
}
let sf_bytes = sf_content.as_bytes();
let cms_der = build_signature_block(&signing_key, sf_bytes)?;
let sig_block_ext = "RSA";
let cursor = Cursor::new(jar_bytes);
let mut zip =
ZipArchive::new(cursor).map_err(|e| anyhow!("Failed to re-open JAR as ZIP: {}", e))?;
let mut modified_jar = Vec::new();
{
let mut writer = zip::ZipWriter::new(Cursor::new(&mut modified_jar));
let text_options: zip::write::FileOptions<'_, ()> =
zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Stored);
writer
.start_file("META-INF/MANIFEST.MF", text_options)
.map_err(|e| anyhow!("Failed to create MANIFEST.MF: {}", e))?;
writer
.write_all(manifest_bytes)
.map_err(|e| anyhow!("Failed to write MANIFEST.MF: {}", e))?;
writer
.start_file("META-INF/SIGNATURE.SF", text_options)
.map_err(|e| anyhow!("Failed to create SIGNATURE.SF: {}", e))?;
writer
.write_all(sf_bytes)
.map_err(|e| anyhow!("Failed to write SF file: {}", e))?;
let sig_block_name = format!("META-INF/SIGNATURE.{}", sig_block_ext);
writer
.start_file(&sig_block_name, text_options)
.map_err(|e| anyhow!("Failed to create signature block file: {}", e))?;
writer
.write_all(&cms_der)
.map_err(|e| anyhow!("Failed to write signature block: {}", e))?;
for i in 0..zip.len() {
let mut file = zip
.by_index(i)
.map_err(|e| anyhow!("Failed to get file {}: {}", i, e))?;
let name = file.name().to_string();
let lower_name = name.to_ascii_lowercase();
if lower_name == "meta-inf/" || lower_name == "meta-inf/manifest.mf" {
continue;
}
if override_signature
&& name.starts_with("META-INF/")
&& (lower_name.ends_with(".sf")
|| lower_name.ends_with(".rsa")
|| lower_name.ends_with(".dsa")
|| lower_name.ends_with(".ec"))
{
continue;
}
progress_callback(name.clone(), false);
let options: zip::write::FileOptions<'_, ()> = zip::write::FileOptions::default()
.compression_method(file.compression())
.unix_permissions(file.unix_mode().unwrap_or(0o644));
writer
.start_file(&name, options)
.map_err(|e| anyhow!("Failed to start file {}: {}", name, e))?;
std::io::copy(&mut file, &mut writer)
.map_err(|e| anyhow!("Failed to copy file {}: {}", name, e))?;
progress_callback(name.clone(), true);
}
writer
.finish()
.map_err(|e| anyhow!("Failed to finish ZIP: {}", e))?;
}
Ok(modified_jar)
}
pub fn extract_signature_bytes(signed_jar_bytes: &[u8]) -> Result<Option<Vec<u8>>> {
let cursor = Cursor::new(signed_jar_bytes);
let mut zip =
ZipArchive::new(cursor).map_err(|e| anyhow!("Failed to open signed JAR: {}", e))?;
for i in 0..zip.len() {
let mut file = zip
.by_index(i)
.map_err(|e| anyhow!("Failed to get file {}: {}", i, e))?;
let name = file.name().to_string();
if name.starts_with("META-INF/")
&& (name.ends_with(".SF") || name.ends_with(".RSA") || name.ends_with(".DSA"))
{
let mut sig_bytes = Vec::new();
std::io::copy(&mut file, &mut sig_bytes)
.map_err(|e| anyhow!("Failed to read signature file {}: {}", name, e))?;
return Ok(Some(sig_bytes));
}
}
Ok(None)
}
pub fn generate_key_pair() -> Result<(Vec<u8>, Vec<u8>)> {
let mut rng = OsRng;
let bits = 2048;
let private_key = rsa::RsaPrivateKey::new(&mut rng, bits)
.map_err(|e| anyhow!("Failed to generate RSA key: {}", e))?;
let signing_key = SigningKey::<Sha256>::new(private_key);
let verifying_key = signing_key.verifying_key();
let private_der = signing_key
.to_pkcs8_der()
.map_err(|e| anyhow!("Failed to encode private key: {}", e))?
.to_bytes()
.to_vec();
let public_der = verifying_key
.to_public_key_der()
.map_err(|e| anyhow!("Failed to encode public key: {}", e))?
.as_bytes()
.to_vec();
Ok((private_der, public_der))
}
pub fn generate_signing_credentials() -> Result<(Vec<u8>, Vec<u8>)> {
generate_key_pair()
}
pub fn is_signed(jar_bytes: &[u8]) -> Result<bool> {
let cursor = Cursor::new(jar_bytes);
let mut zip = ZipArchive::new(cursor).map_err(|e| anyhow!("Failed to open JAR: {}", e))?;
for i in 0..zip.len() {
let file = zip
.by_index(i)
.map_err(|e| anyhow!("Failed to get file {}: {}", i, e))?;
let name = file.name();
if name.starts_with("META-INF/")
&& (name.ends_with(".SF") || name.ends_with(".RSA") || name.ends_with(".DSA"))
{
return Ok(true);
}
}
Ok(false)
}
pub fn verify(jar_bytes: &[u8], public_key_bytes: &[u8]) -> Result<bool> {
let cursor = Cursor::new(jar_bytes);
let mut zip = ZipArchive::new(cursor).map_err(|e| anyhow!("Failed to open JAR: {}", e))?;
let mut sf_content = None;
let mut rsa_content = None;
for i in 0..zip.len() {
let mut file = zip
.by_index(i)
.map_err(|e| anyhow!("Failed to get file {}: {}", i, e))?;
let name = file.name();
if name.starts_with("META-INF/") {
if name.ends_with(".SF") {
let mut content = Vec::new();
std::io::copy(&mut file, &mut content)
.map_err(|e| anyhow!("Failed to read SF file: {}", e))?;
sf_content = Some(content);
} else if name.ends_with(".RSA") || name.ends_with(".DSA") {
let mut content = Vec::new();
std::io::copy(&mut file, &mut content)
.map_err(|e| anyhow!("Failed to read RSA file: {}", e))?;
rsa_content = Some(content);
}
}
}
let sf_bytes = sf_content.ok_or_else(|| anyhow!("No .SF file found"))?;
let rsa_bytes = rsa_content.ok_or_else(|| anyhow!("No .RSA/.DSA file found"))?;
let verifying_key = VerifyingKey::<Sha256>::from_public_key_der(public_key_bytes)
.map_err(|e| anyhow!("Failed to parse public key: {}", e))?;
let content_info = ContentInfo::from_der(&rsa_bytes)
.map_err(|e| anyhow!("Failed to parse PKCS#7 block: {}", e))?;
let signed_data: SignedData = content_info
.content
.decode_as()
.map_err(|e| anyhow!("Failed to decode SignedData: {}", e))?;
let signer_info = signed_data
.signer_infos
.0
.as_slice()
.first()
.ok_or_else(|| anyhow!("No SignerInfo in signature block"))?;
let signature = rsa::pkcs1v15::Signature::try_from(signer_info.signature.as_bytes())
.map_err(|_| anyhow!("Invalid signature format"))?;
verifying_key
.verify(&sf_bytes, &signature)
.map_err(|_| anyhow!("Signature verification failed"))?;
Ok(true)
}
pub fn extract_public_key(jar_bytes: &[u8]) -> Result<Option<Vec<u8>>> {
let cursor = Cursor::new(jar_bytes);
let mut zip = ZipArchive::new(cursor).map_err(|e| anyhow!("Failed to open JAR: {}", e))?;
for i in 0..zip.len() {
let mut file = zip
.by_index(i)
.map_err(|e| anyhow!("Failed to get file {}: {}", i, e))?;
let name = file.name();
if name.starts_with("META-INF/") && (name.ends_with(".RSA") || name.ends_with(".DSA")) {
let mut content = Vec::new();
std::io::copy(&mut file, &mut content)
.map_err(|e| anyhow!("Failed to read signature file: {}", e))?;
if content.len() > 100 {
return Ok(None);
}
}
}
Ok(None)
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Write;
use zip::write::FileOptions;
fn create_test_jar() -> Vec<u8> {
let mut buffer = Vec::new();
{
let mut writer = zip::ZipWriter::new(std::io::Cursor::new(&mut buffer));
let options: zip::write::FileOptions<'_, ()> =
FileOptions::default().compression_method(zip::CompressionMethod::Stored);
writer.start_file("test.txt", options).unwrap();
writer.write_all(b"Hello, World!").unwrap();
writer
.start_file(
"META-INF/",
(FileOptions::default() as zip::write::FileOptions<'_, ()>)
.unix_permissions(0o40755),
)
.unwrap();
writer.start_file("META-INF/config.xml", options).unwrap();
writer.write_all(b"<config/>").unwrap();
writer.finish().unwrap();
}
buffer
}
#[test]
fn test_generate_key_pair() {
let (priv_key, pub_key) = generate_key_pair().unwrap();
assert!(!priv_key.is_empty());
assert!(!pub_key.is_empty());
assert!(priv_key.len() > 100);
assert!(pub_key.len() > 100);
}
#[test]
fn test_generate_signing_credentials() {
let (priv_key, pub_key) = generate_signing_credentials().unwrap();
assert!(!priv_key.is_empty());
assert!(!pub_key.is_empty());
assert!(priv_key.len() > 100);
assert!(pub_key.len() > 100);
}
#[test]
fn test_sign_bytes() {
let jar_bytes = create_test_jar();
let (priv_key, _) = generate_key_pair().unwrap();
let signed_jar = sign_bytes(&jar_bytes, &priv_key, "", false).unwrap();
assert!(!signed_jar.is_empty());
assert!(signed_jar.len() > jar_bytes.len());
}
#[test]
fn test_sign_bytes_with_cert_chain() {
let jar_bytes = create_test_jar();
let (priv_key, _) = generate_signing_credentials().unwrap();
let cert_chain: Vec<Vec<u8>> = vec![];
let signed_jar = sign_bytes_with_cert_chain(
&jar_bytes,
&priv_key,
Some(&cert_chain),
"",
false,
&mut |_, _| {},
)
.unwrap();
assert!(!signed_jar.is_empty());
assert!(signed_jar.len() > jar_bytes.len());
}
#[test]
fn test_sign_bytes_override_signature() {
let jar_bytes = create_test_jar();
let (priv_key, _) = generate_key_pair().unwrap();
let signed_once = sign_bytes(&jar_bytes, &priv_key, "", false).unwrap();
let signed_twice = sign_bytes(&signed_once, &priv_key, "", true).unwrap();
assert!(!signed_twice.is_empty());
}
#[test]
fn test_is_signed() {
let jar_bytes = create_test_jar();
let (priv_key, _) = generate_key_pair().unwrap();
assert!(!is_signed(&jar_bytes).unwrap());
let signed_jar = sign_bytes(&jar_bytes, &priv_key, "", false).unwrap();
assert!(is_signed(&signed_jar).unwrap());
}
#[test]
fn test_extract_signature_bytes() {
let jar_bytes = create_test_jar();
let (priv_key, _) = generate_key_pair().unwrap();
let result = extract_signature_bytes(&jar_bytes);
assert!(result.is_ok());
assert!(result.unwrap().is_none());
let signed_jar = sign_bytes(&jar_bytes, &priv_key, "", false).unwrap();
let result = extract_signature_bytes(&signed_jar);
assert!(result.is_ok());
assert!(result.unwrap().is_some());
}
#[test]
fn test_verify() {
let jar_bytes = create_test_jar();
let (priv_key, pub_key) = generate_key_pair().unwrap();
let signed_jar = sign_bytes(&jar_bytes, &priv_key, "", false).unwrap();
let result = verify(&signed_jar, &pub_key);
assert!(result.is_ok());
}
#[test]
fn test_extract_public_key() {
let jar_bytes = create_test_jar();
let (priv_key, _) = generate_signing_credentials().unwrap();
let cert_chain: Vec<Vec<u8>> = vec![];
let signed_jar = sign_bytes_with_cert_chain(
&jar_bytes,
&priv_key,
Some(&cert_chain),
"",
false,
&mut |_, _| {},
)
.unwrap();
let result = extract_public_key(&signed_jar);
assert!(result.is_ok());
}
#[test]
fn test_sign_empty_jar() {
let mut buffer = Vec::new();
{
let writer = zip::ZipWriter::new(std::io::Cursor::new(&mut buffer));
writer.finish().unwrap();
}
let (priv_key, _) = generate_key_pair().unwrap();
let signed_jar = sign_bytes(&buffer, &priv_key, "", false).unwrap();
assert!(!signed_jar.is_empty());
}
#[test]
fn test_sign_jar_with_meta_inf_files() {
let jar_bytes = create_test_jar();
let (priv_key, _) = generate_key_pair().unwrap();
let signed_jar = sign_bytes(&jar_bytes, &priv_key, "", false).unwrap();
let cursor = std::io::Cursor::new(&signed_jar);
let mut zip = ZipArchive::new(cursor).unwrap();
let mut has_manifest = false;
let mut has_sf = false;
let mut has_rsa = false;
for i in 0..zip.len() {
let file = zip.by_index(i).unwrap();
let name = file.name();
if name == "META-INF/MANIFEST.MF" {
has_manifest = true;
} else if name == "META-INF/SIGNATURE.SF" {
has_sf = true;
} else if name == "META-INF/SIGNATURE.RSA" {
has_rsa = true;
}
}
assert!(has_manifest);
assert!(has_sf);
assert!(has_rsa);
}
#[test]
fn test_sign_preserves_main_manifest_attributes() {
let mut buffer = Vec::new();
{
let mut writer = zip::ZipWriter::new(std::io::Cursor::new(&mut buffer));
let stored: zip::write::FileOptions<'_, ()> =
FileOptions::default().compression_method(zip::CompressionMethod::Stored);
writer.start_file("META-INF/MANIFEST.MF", stored).unwrap();
writer
.write_all(
b"Manifest-Version: 1.0\r\n\
Multi-Release: true\r\n\
FMLCorePlugin: com.example.CorePlugin\r\n\
FMLCorePluginContainsFMLMod: true\r\n\
TweakClass: org.spongepowered.asm.launch.MixinTweaker\r\n\
MixinConfigs: mixins.example.json\r\n\r\n",
)
.unwrap();
writer.start_file("a/B.class", stored).unwrap();
writer.write_all(b"\xca\xfe\xba\xbe").unwrap();
writer.finish().unwrap();
}
let (priv_key, _) = generate_key_pair().unwrap();
let signed = sign_bytes(&buffer, &priv_key, "", true).unwrap();
let mut zip = ZipArchive::new(std::io::Cursor::new(&signed)).unwrap();
let mut mf = String::new();
zip.by_name("META-INF/MANIFEST.MF").unwrap().read_to_string(&mut mf).unwrap();
let main = mf.split("\r\n\r\n").next().unwrap();
for attr in [
"Multi-Release: true",
"FMLCorePlugin: com.example.CorePlugin",
"FMLCorePluginContainsFMLMod: true",
"TweakClass: org.spongepowered.asm.launch.MixinTweaker",
"MixinConfigs: mixins.example.json",
] {
assert!(main.contains(attr), "signing dropped manifest attribute: {attr}\nGot:\n{main}");
}
}
#[test]
fn test_invalid_key() {
let jar_bytes = create_test_jar();
let invalid_key = b"invalid key data";
let result = sign_bytes(&jar_bytes, invalid_key, "", false);
assert!(result.is_err());
}
#[test]
fn test_invalid_jar() {
let invalid_jar = b"not a jar";
let (priv_key, _) = generate_key_pair().unwrap();
let result = sign_bytes(invalid_jar, &priv_key, "", false);
assert!(result.is_err());
}
}