hancock

	"time"

	"github.com/pkg/errors"
	"golang.org/x/crypto/ssh"
	"src.d10.dev/command"
	"src.d10.dev/hancock/model"
)
























































func init() {
	command.RegisterOperation(command.Operation{
		Handler:     verifyMain,
		Name:        "verify",
		Syntax:      "verify -index <URL> [-r] <file or directory> [...]",
		Description: "Check the authenticity of a source file.",
................................................................................
	defaultIndex := cfg.Section("").Key("index").MustString("https://hancock.beyondcentral.com")
	defaultIPFS := cfg.Section("").Key("ipfs").MustString("http://localhost:8080")

	strictFlag := command.OperationFlagSet.Bool("strict", false, "strict mode requires source to be endorsed")
	command.OperationFlagSet.Var(&verifyIndexFlag, "index", fmt.Sprintf("URL of authenticity index (default %s)", defaultIndex))
	ipfsFlag := command.OperationFlagSet.String("ipfs", defaultIPFS, "URL of manifests")
	recurseFlag := command.OperationFlagSet.Bool("r", false, "verify all files in directory")

	err = command.OperationFlagSet.Parse(command.Args()[1:])
	if err != nil {
		return err
	}
	if len(verifyIndexFlag) == 0 && len(defaultIndex) > 0 {
		verifyIndexFlag = append(verifyIndexFlag, strings.Split(defaultIndex, ",")...) // comma separated list allowed in config file
	}
................................................................................
	}
	// TODO(dnc): validate an index is reachable

	if len(command.OperationFlagSet.Args()) == 0 {
		return errors.New("Expected <file or directory> parameter.")
	}

	// authorized keys, from config files
	type auth struct {
		name   string
		public ssh.PublicKey
	}

	authorities := make([]auth, 0)
	for _, key := range cfg.Section("authority").Keys() {
		public, _, _, _, err := ssh.ParseAuthorizedKey([]byte(key.Value()))
		if err != nil {
			command.Check(errors.Wrapf(err, "failed to parse public key (%q %q)", key, key.Value()))
		}
		authorities = append(authorities, auth{key.Name(), public})
	}

	httpclient := http.Client{
		Timeout: time.Duration(10 * time.Second),
	}

	noRecurse := errors.New("no recurse") // prepare for filepath.Walk





	// TODO(dnc): goroutines for performance
	for _, arg := range command.OperationFlagSet.Args() {
		err = filepath.Walk(arg, func(filepath string, info os.FileInfo, err error) error {
			if err != nil {
				command.Error(err) // log error
				return nil         // continue walk
			}
			if info.IsDir() {
				if *recurseFlag == false {
					return noRecurse // end of walk
				} else {
					return nil // noop (we only process files)
				}
			}

			verified := false



			f, err := os.Open(filepath)
			if err != nil {
				command.Error(errors.Wrapf(err, "failed to open file (%q)", filepath))
				return nil // continue walk
			}
			defer f.Close()
			cid := model.NewSha256CID(nil)
			_, err = io.Copy(cid, f)
			if err != nil {
				command.Error(err)
................................................................................
								continue
							}

							// checks
							err = testimony.Verify()
							if err != nil {
								// BUG(dnc): may not be an error, if another valid testimony applies to the same file.
								command.Info(errors.Wrapf(err, "invalid testimony (%q)", filepath))
								continue
							}

							// path check is disabled because an identical file may appear in more than one place.  TODO(dnc) fix this, or enable strict mode
							//if manifest.Path != filepath {
							//	command.Infof("path mismatch (local: %q, testimony: %q)", filepath, manifest.Path)
							//	continue
							//}

							timestamp := time.Unix(manifest.Time, 0)

							if manifest.Quality&model.Valid == 0 {
								// Testimony is repudiation.
								command.Errorf("%q repudiated by %s (%q) as %s on %s", filepath, manifest.Role, authority.name, model.QualityString(manifest.Quality), timestamp.Format(time.RFC850)) // Errorf will cause non-zero exit status





								continue
							}

							if command.V(1) {
								// TODO(dnc) format time in friendly "days ago" syntax
								if filepath != manifest.Path {
									command.Infof("%q confirmed by %s (%q) as %q on %s", filepath, manifest.Role, authority.name, manifest.Path, timestamp.Format(time.RFC850))
								} else {
									command.Infof("%q confirmed by %s (%q) on %s", filepath, manifest.Role, authority.name, timestamp.Format(time.RFC850))
								}

							}
							verified = true // TODO(dnc): consider a count of weighted authorities, rather than simple verified or not
						default:
							command.V(2).Info(filepath, u.String(), resp.Status)
							continue
						} // end ipfs status
					default:
						command.V(2).Info(filepath, u.String(), resp.Status)
					} // end index status
				} // end index loop
			} // end authority loop

			if !verified {
				if *strictFlag {
					// command.Error sets exit status code (not zero)
					command.Errorf("%q not verified", filepath)
					command.Exit() // exit early when strict mode (should this be only when verbose is off?)
				} else if command.V(2) {
					command.Infof("%q not verified", filepath)
				}
			}
			return nil // continue file walk
		})
		if err == noRecurse {
			return fmt.Errorf("Expected file name. Use -r to recurse directories (%q).", arg)
		} else if err != nil {
			command.Error(err) // log error, continue arg loop
		}
	}












	return nil
}

	"time"

	"github.com/pkg/errors"
	"golang.org/x/crypto/ssh"
	"src.d10.dev/command"
	"src.d10.dev/hancock/model"
)

// Produce a summary of human-readable information with a minimum of
// redundancy.
type SummaryMessages map[string]int // key is human-readable message, count is how many times it was produced

type Summary map[string]SummaryMessages // key is directory that was inspected

func (summary Summary) summarize(typ string, currentFile string, manifest model.FileManifest, authority Authority) {
	// Produce summary.  Messages repeated for multiple
	// files should appear once in the summary.  So, omit
	// file-specific info.
	currentDir := filepath.Dir(currentFile)

	_, ok := summary[currentDir]
	if !ok {
		summary[currentDir] = make(SummaryMessages)
	}
	timestamp := time.Unix(manifest.Time, 0)

	for _, m := range manifest.Message {
		msg := fmt.Sprintf("%s (%s) by %s: %s", typ, model.QualityString(manifest.Quality), authority.name, m)
		count, _ := summary[currentDir][msg]
		summary[currentDir][msg] = count + 1

		if command.V(1) { // control verbosity
			if currentFile == manifest.Path {
				command.Errorf("%q %s on %s: %s", currentFile, manifest.Role, timestamp.Format(time.RFC850), msg)
			} else {
				command.Errorf("%q (as %q) %s on %s: %s", currentFile, manifest.Path, manifest.Role, timestamp.Format(time.RFC850), msg)
			}
		}
	}
	if len(manifest.Message) == 0 {
		// no explicit message
		msg := fmt.Sprintf("%s (%s) by %s", typ, model.QualityString(manifest.Quality), authority.name)
		count, _ := summary[currentDir][msg]
		summary[currentDir][msg] = count + 1

		if command.V(1) { // control verbosity
			if currentFile == manifest.Path {
				command.Errorf("%q %s on %s: %s", currentFile, manifest.Role, timestamp.Format(time.RFC850), msg)
			} else {
				command.Errorf("%q (as %q) %s on %s: %s", currentFile, manifest.Path, manifest.Role, timestamp.Format(time.RFC850), msg)
			}
		}

	}

}

// authorized keys, from config files
type Authority struct {
	name   string
	public ssh.PublicKey
}

func init() {
	command.RegisterOperation(command.Operation{
		Handler:     verifyMain,
		Name:        "verify",
		Syntax:      "verify -index <URL> [-r] <file or directory> [...]",
		Description: "Check the authenticity of a source file.",
................................................................................
	defaultIndex := cfg.Section("").Key("index").MustString("https://hancock.beyondcentral.com")
	defaultIPFS := cfg.Section("").Key("ipfs").MustString("http://localhost:8080")

	strictFlag := command.OperationFlagSet.Bool("strict", false, "strict mode requires source to be endorsed")
	command.OperationFlagSet.Var(&verifyIndexFlag, "index", fmt.Sprintf("URL of authenticity index (default %s)", defaultIndex))
	ipfsFlag := command.OperationFlagSet.String("ipfs", defaultIPFS, "URL of manifests")
	recurseFlag := command.OperationFlagSet.Bool("r", false, "verify all files in directory")

	err = command.OperationFlagSet.Parse(command.Args()[1:])
	if err != nil {
		return err
	}
	if len(verifyIndexFlag) == 0 && len(defaultIndex) > 0 {
		verifyIndexFlag = append(verifyIndexFlag, strings.Split(defaultIndex, ",")...) // comma separated list allowed in config file
	}
................................................................................
	}
	// TODO(dnc): validate an index is reachable

	if len(command.OperationFlagSet.Args()) == 0 {
		return errors.New("Expected <file or directory> parameter.")
	}







	authorities := make([]Authority, 0)
	for _, key := range cfg.Section("authority").Keys() {
		public, _, _, _, err := ssh.ParseAuthorizedKey([]byte(key.Value()))
		if err != nil {
			command.Check(errors.Wrapf(err, "failed to parse public key (%q %q)", key, key.Value()))
		}
		authorities = append(authorities, Authority{key.Name(), public})
	}

	httpclient := http.Client{
		Timeout: time.Duration(10 * time.Second),
	}

	noRecurse := errors.New("no recurse") // prepare for filepath.Walk

	// Exit status
	status := 0
	summary := make(Summary)

	// TODO(dnc): goroutines for performance
	for _, arg := range command.OperationFlagSet.Args() {
		err = filepath.Walk(arg, func(currentFile string, info os.FileInfo, err error) error {
			if err != nil {
				command.Error(err) // log error
				return nil         // continue walk
			}
			if info.IsDir() {
				if *recurseFlag == false {
					return noRecurse // end of walk
				} else {
					return nil // noop (we only process files)
				}
			}

			verified := false
			repudiated := false
			_ = repudiated // not yet used

			f, err := os.Open(currentFile)
			if err != nil {
				command.Error(errors.Wrapf(err, "failed to open file (%q)", currentFile))
				return nil // continue walk
			}
			defer f.Close()
			cid := model.NewSha256CID(nil)
			_, err = io.Copy(cid, f)
			if err != nil {
				command.Error(err)
................................................................................
								continue
							}

							// checks
							err = testimony.Verify()
							if err != nil {
								// BUG(dnc): may not be an error, if another valid testimony applies to the same file.
								command.Info(errors.Wrapf(err, "invalid testimony (%q)", currentFile))
								continue
							}

							// path check is disabled because an identical file may appear in more than one place.  TODO(dnc) fix this, or enable strict mode
							//if manifest.Path != currentFile {
							//	command.Infof("path mismatch (local: %q, testimony: %q)", currentFile, manifest.Path)
							//	continue
							//}



							if manifest.Quality&model.Valid == 0 {
								// Testimony is repudiation.

								repudiated = true
								status = 1 // non-zero exit status

								summary.summarize("repudiated", currentFile, manifest, authority)

								continue
							}

							verified = true // TODO(dnc): consider a count of weighted authorities, rather than simple verified or not






							summary.summarize("confirmed", currentFile, manifest, authority)


						default:
							command.V(2).Info(currentFile, u.String(), resp.Status)
							continue
						} // end ipfs status
					default:
						command.V(2).Info(currentFile, u.String(), resp.Status)
					} // end index status
				} // end index loop
			} // end authority loop

			if !verified {
				if *strictFlag {
					// command.Error sets exit status code (not zero)
					command.Errorf("%q not verified", currentFile)
					command.Exit() // exit early when strict mode (should this be only when verbose is off?)
				} else if command.V(2) {
					command.Infof("%q not verified", currentFile)
				}
			}
			return nil // continue file walk
		})
		if err == noRecurse {
			return fmt.Errorf("Expected file name. Use -r to recurse directories (%q).", arg)
		} else if err != nil {
			command.Error(err) // log error, continue arg loop
		}
	}

	// write summary
	for dir, sum := range summary {
		for m, count := range sum {
			if dir == "." {
				fmt.Printf("%d files %s\n", count, m)
			} else {
				fmt.Printf("%d files in %q %s\n", count, dir, m)
			}
		}
	}
	os.Exit(status)
	return nil
}